def _start_web_server():
server.start_webserver(
options=ParaViewIPython.webArguments,
protocol=ParaViewIPython.webProtocol)
from paraview import simple
simple.Disconnect()
ParaViewIPython.localController.TriggerBreakRMIs()
type=int,
help="Port number to connect to for DataServer",
dest="dsPort")
parser.add_argument("--rs-host",
default=None,
help="Hostname to connect to for RenderServer",
dest="rsHost")
parser.add_argument("--rs-port",
default=11111,
type=int,
help="Port number to connect to for RenderServer",
dest="rsPort")
# Exctract arguments
args = parser.parse_args()
# Configure our current application
_FileOpener.pathToList = args.path
_FileOpener.authKey = args.authKey
_FileOpener.dsHost = args.dsHost
_FileOpener.dsPort = args.dsPort
_FileOpener.rsHost = args.rsHost
_FileOpener.rsPort = args.rsPort
if args.data:
_FileOpener.fileToLoad = os.path.join(_FileOpener.pathToList,
args.data)
# Start server
server.start_webserver(options=args, protocol=_FileOpener)
def visualization(partitionId, iterator):
# Setup MPI context
import os
os.environ["PMI_PORT"] = pmi_port
os.environ["PMI_ID"] = str(partitionId)
os.environ["PV_ALLOW_BATCH_INTERACTION"] = "1"
os.environ["DISPLAY"] = ":0"
numYears = 0
localYears = []
localAvgData = []
for item in iterator:
numYears += 1
print(
'visualize (partition %d) peeking at next year %s, shape = [%d, %d]'
% (partitionId, item[0], item[1].shape[1], item[1].shape[0]))
localYears.append(item[0])
localAvgData.append(item[1])
sizeX = localAvgData[0].shape[1]
sizeY = localAvgData[0].shape[0]
sliceSize = sizeX * sizeY
localNumSlices = numYears
size = localNumSlices * sliceSize
print(
'visualize, partition id = %d, sizeX = %d, sizeY = %d, sliceSize = %d, localNumSlices = %d, size = %d'
% (partitionId, sizeX, sizeY, sliceSize, localNumSlices, size))
# Copy data from iterator into data chunk
t0 = time.time()
count = 0
globalSliceIndices = []
dataChunk = np.arange(size, dtype=np.float32)
sidChunk = np.arange(size, dtype=np.uint8)
for localSliceIdx in range(len(localYears)):
globalSliceIdx = allYearsList.index(localYears[localSliceIdx])
globalSliceIndices.append(globalSliceIdx)
nextAvgArray = localAvgData[localSliceIdx]
(imgHeight, imgWidth) = nextAvgArray.shape
for y in range(imgHeight):
for x in range(imgWidth):
count += 1
pixelValue = nextAvgArray[y][x]
destIdx = x + (y * sizeX) + (localSliceIdx * sliceSize)
dataChunk[destIdx] = pixelValue
sidChunk[destIdx] = globalSliceIdx
t1 = time.time()
print('%d # MPI Gather %s | %d' % (partitionId, str(t1 - t0), count))
t0 = t1
# Configure Paraview for MPI
import paraview
paraview.options.batch = True
from vtk.vtkPVVTKExtensionsCore import vtkDistributedTrivialProducer
from vtk.vtkCommonCore import vtkIntArray, vtkUnsignedCharArray, vtkFloatArray
from vtk.vtkCommonDataModel import vtkImageData, vtkPointData
# -------------------------------------------------------------------------
dataset = vtkImageData()
sliceIdxArray = vtkUnsignedCharArray()
sliceIdxArray.SetName('Slice Index')
sliceIdxArray.SetNumberOfComponents(1)
sliceIdxArray.SetNumberOfTuples(size)
dataArray = vtkFloatArray()
dataArray.SetName('Annual Avg Temp')
dataArray.SetNumberOfComponents(1)
dataArray.SetNumberOfTuples(size)
for i in range(size):
dataArray.SetTuple1(i, dataChunk[i])
sliceIdxArray.SetTuple1(i, sidChunk[i])
minZ = globalSliceIndices[0]
maxZ = globalSliceIndices[-1]
print('partition %d extents: [%d, %d, %d, %d, %d, %d]' %
(partitionId, 0, sizeX, 0, sizeY, minZ, maxZ + 1))
dataset.SetExtent(0, sizeX, 0, sizeY, minZ, maxZ + 1)
dataset.GetCellData().SetScalars(dataArray)
procIdArray = vtkUnsignedCharArray()
procIdArray.SetName('Process Id')
procIdArray.SetNumberOfComponents(1)
procIdArray.SetNumberOfTuples(size)
for i in range(size):
procIdArray.SetTuple1(i, partitionId)
dataset.GetCellData().AddArray(procIdArray)
dataset.GetCellData().AddArray(sliceIdxArray)
t1 = time.time()
print('%d # build resulting image data %s | ' %
(partitionId, str(t1 - t0)))
t0 = t1
# -------------------------------------------------------------------------
vtkDistributedTrivialProducer.SetGlobalOutput('Spark', dataset)
from vtk.vtkPVClientServerCoreCore import vtkProcessModule
from paraview import simple
from vtk.web import server
from paraview.web import wamp as pv_wamp
from paraview.web import protocols as pv_protocols
class _VisualizerServer(pv_wamp.PVServerProtocol):
dataDir = '/data'
groupRegex = "[0-9]+\\.[0-9]+\\.|[0-9]+\\."
excludeRegex = "^\\.|~$|^\\$"
allReaders = True
viewportScale = 1.0
viewportMaxWidth = 2560
viewportMaxHeight = 1440
def initialize(self):
# Bring used components
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebFileListing(
_VisualizerServer.dataDir, "Home",
_VisualizerServer.excludeRegex,
_VisualizerServer.groupRegex))
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebProxyManager(
baseDir=_VisualizerServer.dataDir,
allowUnconfiguredReaders=_VisualizerServer.allReaders))
self.registerVtkWebProtocol(pv_protocols.ParaViewWebColorManager())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebMouseHandler())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebViewPort(
_VisualizerServer.viewportScale,
_VisualizerServer.viewportMaxWidth,
_VisualizerServer.viewportMaxHeight))
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebViewPortImageDelivery())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebViewPortGeometryDelivery())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebTimeHandler())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebSelectionHandler())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebWidgetManager())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebKeyValuePairStore())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebSaveData(
baseSavePath=_VisualizerServer.dataDir))
# Disable interactor-based render calls
simple.GetRenderView().EnableRenderOnInteraction = 0
simple.GetRenderView().Background = [0, 0, 0]
# Update interaction mode
pxm = simple.servermanager.ProxyManager()
interactionProxy = pxm.GetProxy('settings',
'RenderViewInteractionSettings')
interactionProxy.Camera3DManipulators = [
'Rotate', 'Pan', 'Zoom', 'Pan', 'Roll', 'Pan', 'Zoom',
'Rotate', 'Zoom'
]
pm = vtkProcessModule.GetProcessModule()
# -------------------------------------------------------------------------
print('%d # > Start visualization - %s | ' %
(partitionId, str(datetime.now())))
# -------------------------------------------------------------------------
args = Options()
if pm.GetPartitionId() == 0:
print('%d # ==> %d' % (partitionId, pm.GetPartitionId()))
producer = simple.DistributedTrivialProducer()
producer.UpdateDataset = ''
producer.UpdateDataset = 'Spark'
print(
'rank 0 process setting whole extent to [%d, %d, %d, %d, %d, %d]' %
(0, sizeX, 0, sizeY, 0, sizeZ))
producer.WholeExtent = [0, sizeX, 0, sizeY, 0, sizeZ]
server.start_webserver(options=args, protocol=_VisualizerServer)
pm.GetGlobalController().TriggerBreakRMIs()
print('%d # < Stop visualization - %s | ' %
(partitionId, str(datetime.now())))
yield (partitionId, nbMPIPartition)
return self.sideNames
@exportRpc('toggle.bg.color')
def changeBgColor(self):
# FIXME when we get the right face names
bgColor = self.view.Background[0]
bgColor = bgColor + 0.5
if bgColor > 1.0:
bgColor = 0
self.view.Background = [bgColor, bgColor, bgColor]
if bgColor == 1.0:
self.outline.AmbientColor = [0.0,0.0,0.0]
else:
self.outline.AmbientColor = [1.0,1.0,1.0]
# =============================================================================
# Main: Parse args and start server
# =============================================================================
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(description="Mesh Viewer")
# Add arguments
server.add_arguments(parser)
_MeshViewer.add_arguments(parser)
args = parser.parse_args()
_MeshViewer.configure(args)
# Start server
server.start_webserver(options=args, protocol=_MeshViewer)
def visualization(partitionId, iterator):
# Setup MPI context
import os
os.environ["PMI_PORT"] = pmi_port
os.environ["PMI_ID"] = str(partitionId)
os.environ["PV_ALLOW_BATCH_INTERACTION"] = "1"
os.environ["DISPLAY"] = ":0"
localNumSlices = processSlices[partitionId]
size = localNumSlices * sliceSize
kOffset = 0
for i in range(partitionId):
kOffset += processSlices[i]
# Copy data from iterator into data chunk
t0 = time.time()
count = 0
dataChunk = np.arange(size, dtype=np.float32)
sidChunk = np.arange(size, dtype=np.uint8)
for item in iterator:
count += 1
globalIndex = item[0]
pixelValue = item[1]
# print('%d # %d: %f' % (partitionId, globalIndex, pixelValue))
ijk = _ijk(globalIndex)
ijk[2] -= kOffset
destIdx = ijk[0] + (ijk[1] * sizeX) + (ijk[2] * sliceSize)
dataChunk[destIdx] = pixelValue
sidChunk[destIdx] = ijk[2] + kOffset
t1 = time.time()
print('%d # MPI Gather %s | %d' % (partitionId, str(t1 - t0), count))
t0 = t1
# Configure Paraview for MPI
import paraview
paraview.options.batch = True
from vtk.vtkPVVTKExtensionsCore import vtkDistributedTrivialProducer
from vtk.vtkCommonCore import vtkIntArray, vtkUnsignedCharArray, vtkFloatArray
from vtk.vtkCommonDataModel import vtkImageData, vtkPointData
# -------------------------------------------------------------------------
dataset = vtkImageData()
sliceIdxArray = vtkUnsignedCharArray()
sliceIdxArray.SetName('Slice Index')
sliceIdxArray.SetNumberOfComponents(1)
sliceIdxArray.SetNumberOfTuples(size)
dataArray = vtkFloatArray()
dataArray.SetName('Annual Avg Temp')
dataArray.SetNumberOfComponents(1)
dataArray.SetNumberOfTuples(size)
for i in range(size):
dataArray.SetTuple1(i, dataChunk[i])
sliceIdxArray.SetTuple1(i, sidChunk[i])
minZ = 0
maxZ = 0
for i in range(partitionId + 1):
minZ = maxZ
maxZ += processSlices[i]
# dataset.SetExtent(0, sizeX - 1, 0, sizeY - 1, minZ, maxZ - 1)
# print('partition %d extents: [%d, %d, %d, %d, %d, %d]' % (partitionId, 0, sizeX - 1, 0, sizeY - 1, minZ, maxZ - 1))
dataset.SetExtent(0, sizeX, 0, sizeY, minZ, maxZ)
print('partition %d extents: [%d, %d, %d, %d, %d, %d]' % (partitionId, 0, sizeX, 0, sizeY, minZ, maxZ))
#dataset.GetPointData().AddArray(dataArray)
# dataset.GetPointData().SetScalars(dataArray)
dataset.GetCellData().SetScalars(dataArray)
procIdArray = vtkUnsignedCharArray()
procIdArray.SetName('Process Id')
procIdArray.SetNumberOfComponents(1)
procIdArray.SetNumberOfTuples(size)
for i in range(size):
procIdArray.SetTuple1(i, partitionId)
dataset.GetCellData().AddArray(procIdArray)
dataset.GetCellData().AddArray(sliceIdxArray)
t1 = time.time()
print('%d # build resulting image data %s | ' % (partitionId, str(t1 - t0)))
t0 = t1
# -------------------------------------------------------------------------
vtkDistributedTrivialProducer.SetGlobalOutput('Spark', dataset)
from vtk.vtkPVClientServerCoreCore import vtkProcessModule
from paraview import simple
from vtk.web import server
from paraview.web import wamp as pv_wamp
from paraview.web import protocols as pv_protocols
class _VisualizerServer(pv_wamp.PVServerProtocol):
dataDir = '/data'
groupRegex = "[0-9]+\\.[0-9]+\\.|[0-9]+\\."
excludeRegex = "^\\.|~$|^\\$"
allReaders = True
viewportScale=1.0
viewportMaxWidth=2560
viewportMaxHeight=1440
def initialize(self):
# Bring used components
self.registerVtkWebProtocol(pv_protocols.ParaViewWebFileListing(_VisualizerServer.dataDir, "Home", _VisualizerServer.excludeRegex, _VisualizerServer.groupRegex))
self.registerVtkWebProtocol(pv_protocols.ParaViewWebProxyManager(baseDir=_VisualizerServer.dataDir, allowUnconfiguredReaders=_VisualizerServer.allReaders))
self.registerVtkWebProtocol(pv_protocols.ParaViewWebColorManager())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebMouseHandler())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebViewPort(_VisualizerServer.viewportScale, _VisualizerServer.viewportMaxWidth,
_VisualizerServer.viewportMaxHeight))
self.registerVtkWebProtocol(pv_protocols.ParaViewWebViewPortImageDelivery())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebViewPortGeometryDelivery())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebTimeHandler())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebSelectionHandler())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebWidgetManager())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebKeyValuePairStore())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebSaveData(baseSavePath=_VisualizerServer.dataDir))
# Disable interactor-based render calls
simple.GetRenderView().EnableRenderOnInteraction = 0
simple.GetRenderView().Background = [0,0,0]
# Update interaction mode
pxm = simple.servermanager.ProxyManager()
interactionProxy = pxm.GetProxy('settings', 'RenderViewInteractionSettings')
interactionProxy.Camera3DManipulators = ['Rotate', 'Pan', 'Zoom', 'Pan', 'Roll', 'Pan', 'Zoom', 'Rotate', 'Zoom']
pm = vtkProcessModule.GetProcessModule()
# -------------------------------------------------------------------------
print('%d # > Start visualization - %s | ' % (partitionId, str(datetime.now())))
# -------------------------------------------------------------------------
args = Options()
if pm.GetPartitionId() == 0:
print('%d # ==> %d' % (partitionId, pm.GetPartitionId()))
producer = simple.DistributedTrivialProducer()
producer.UpdateDataset = ''
producer.UpdateDataset = 'Spark'
producer.WholeExtent = [0, sizeX, 0, sizeY, 0, sizeZ]
server.start_webserver(options=args, protocol=_VisualizerServer)
pm.GetGlobalController().TriggerBreakRMIs()
print('%d # < Stop visualization - %s | ' % (partitionId, str(datetime.now())))
yield (partitionId, nbMPIPartition)
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(description="ParaView/Web file loader web-application")
# Add default arguments
server.add_arguments(parser)
# Add local arguments
parser.add_argument("--file-to-load", help="relative file path to load based on --data-dir argument", dest="data")
parser.add_argument("--data-dir", default=os.getcwd(), help="Base path directory", dest="path")
parser.add_argument("--ds-host", default=None, help="Hostname to connect to for DataServer", dest="dsHost")
parser.add_argument("--ds-port", default=11111, type=int, help="Port number to connect to for DataServer", dest="dsPort")
parser.add_argument("--rs-host", default=None, help="Hostname to connect to for RenderServer", dest="rsHost")
parser.add_argument("--rs-port", default=11111, type=int, help="Port number to connect to for RenderServer", dest="rsPort")
# Exctract arguments
args = parser.parse_args()
# Configure our current application
_FileOpener.fileToLoad = args.data
_FileOpener.pathToList = args.path
_FileOpener.authKey = args.authKey
_FileOpener.dsHost = args.dsHost
_FileOpener.dsPort = args.dsPort
_FileOpener.rsHost = args.rsHost
_FileOpener.rsPort = args.rsPort
# Start server
server.start_webserver(options=args, protocol=_FileOpener)
# Add local arguments
parser.add_argument("--data-dir",
default=os.getcwd(),
help="path to ParaView data directory",
dest="path")
parser.add_argument(
"--echo",
default="",
help="A string that will be available through echo protocol",
dest="echoString")
parser.add_argument(
"--proxy-file",
default=None,
type=str,
help=
"Path to a file containing the list of allowed filter and source proxies",
dest="proxyFile")
# Exctract arguments
args = parser.parse_args()
# Configure our current application
_TestApp.dataDir = args.path
_TestApp.authKey = args.authKey
_TestApp.echoStr = args.echoString
_TestApp.proxyFile = args.proxyFile
# Start server
server.start_webserver(options=args, protocol=_TestApp)
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(description="ParaView/Web Pipeline Manager web-application")
# Add default arguments
server.add_arguments(parser)
# Add local arguments
parser.add_argument("--data-dir", default=os.getcwd(), help="path to data directory to list", dest="path")
parser.add_argument("--load-file", default=None, help="File to load if any based on data-dir base path", dest="file")
parser.add_argument("--ds-host", default=None, help="Hostname to connect to for DataServer", dest="dsHost")
parser.add_argument("--ds-port", default=11111, type=int, help="Port number to connect to for DataServer", dest="dsPort")
parser.add_argument("--rs-host", default=None, help="Hostname to connect to for RenderServer", dest="rsHost")
parser.add_argument("--rs-port", default=11111, type=int, help="Port number to connect to for RenderServer", dest="rsPort")
# Exctract arguments
args = parser.parse_args()
# Configure our current application
_PipelineManager.authKey = args.authKey
_PipelineManager.dataDir = args.path
_PipelineManager.dsHost = args.dsHost
_PipelineManager.dsPort = args.dsPort
_PipelineManager.rsHost = args.rsHost
_PipelineManager.rsPort = args.rsPort
if args.file:
_PipelineManager.fileToLoad = args.path + '/' + args.file
# Start server
server.start_webserver(options=args, protocol=_PipelineManager)
try:
usermod = imp.load_source("usermod", userfile)
except IOError:
print >>sys.stderr, "error: could not open file '%s'" % (userfile)
sys.exit(2)
except ImportError as e:
print >>sys.stderr, "error: could not import module '%s'" % (userfile)
print >>sys.stderr, "({})".format(e)
sys.exit(2)
# Create argument parser
parser = argparse.ArgumentParser(description="Tangelo/VTKWeb application")
# Add default arguments
server.add_arguments(parser)
# Add local arguments, if any are specified in the user module.
if "add_arguments" in usermod.__dict__:
usermod.add_arguments(parser)
# Extract arguments (dropping the "usermodule" argument first).
del sys.argv[1]
args = parser.parse_args()
# Configure our current application
VTKWebApp = VTKWebAppProtocol(args, usermod)
VTKWebApp.authKey = args.authKey
# Start server
server.start_webserver(options=args, protocol=VTKWebApp)
# Bring used components
self.registerVtkWebProtocol(protocols.vtkWebFileBrowser(_WebFileBrowser.basedir, "Home"))
# Update authentication key to use
self.updateSecret(_WebFileBrowser.authKey)
# =============================================================================
# Main: Parse args and start server
# =============================================================================
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(description="VTK/Web FileBrowser web-application")
# Add default arguments
server.add_arguments(parser)
# Add local arguments
parser.add_argument("--data-dir", help="Base directory to list", dest="basedir", default=".")
# Exctract arguments
args = parser.parse_args()
# Configure our current application
_WebFileBrowser.authKey = args.authKey
_WebFileBrowser.basedir = args.basedir
# Start server
server.start_webserver(options=args, protocol=_WebFileBrowser)
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(
description="VTK/Web Graph web-application")
# Add default arguments
server.add_arguments(parser)
# Add local arguments
parser.add_argument("--vertices",
help="Number of vertices used to generate graph",
dest="vertices",
type=int,
default=1000)
parser.add_argument("--edges",
help="Number of edges used to generate graph",
dest="edges",
type=int,
default=400)
# Exctract arguments
args = parser.parse_args()
# Configure our current application
_WebGraph.authKey = args.authKey
_WebGraph.vertices = args.vertices
_WebGraph.edges = args.edges
# Start server
server.start_webserver(options=args, protocol=_WebGraph)
self.rep.ScalarOpacityFunction = self.sof
self.rep.ColorArrayName = self.colorArrayName
self.rep.Representation = 'Volume'
self.rep.SelectionPointFieldDataArrayName = self.colorArrayName
self.rep.LookupTable = self.lookupTable
simple.Hide(self.srcObj)
simple.SetActiveSource(self.subgrid)
simple.Render()
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description="Midas+ParaViewWeb application")
server.add_arguments(parser)
parser.add_argument("--data-dir", default=os.getcwd(),
help="path to data directory", dest="path")
parser.add_argument("--width", default=575,
help="width of the render window", dest="width")
parser.add_argument("--height", default=575,
help="height of the render window", dest="height")
args = parser.parse_args()
dataPath = args.path
authKey = args.authKey
width = args.width
height = args.height
initView(width, height)
server.start_webserver(options=args, protocol=MidasApp)
try:
os.makedirs(os.path.dirname(dest_path))
except:
pass
with open(dest_path, 'w') as fp:
fp.write(r.content)
elif len(files) > 1:
# Download the item in zip format
item_url = '%s/item/%s/download' % (_ResultViewer.url, item_id)
r = requests.get(item_url, headers=self._headers)
self._check_status(r)
files = zipfile.ZipFile(io.BytesIO(r.content))
dest_path = os.path.join(_ResultViewer.dataDir)
files.extractall(dest_path)
# =============================================================================
# Main: Parse args and start server
# =============================================================================
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(description="Mesh Viewer")
# Add arguments
server.add_arguments(parser)
_ResultViewer.add_arguments(parser)
args = parser.parse_args()
_ResultViewer.configure(args)
# Start server
server.start_webserver(options=args, protocol=_ResultViewer)
if _PVCatalystManager.pipeline_handler:
return _PVCatalystManager.pipeline_handler.get_metadata()
else:
return { "time": {
"default": "0",
"type": "range",
"values": self.time_steps,
"label": "time",
"priority": 0 } }
# =============================================================================
# Main: Parse args and start server
# =============================================================================
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(description="ParaView/Web Pipeline Manager web-application")
# Add arguments
server.add_arguments(parser)
_PVCatalystManager.add_arguments(parser)
# Exctract arguments
args = parser.parse_args()
# Configure our current application
_PVCatalystManager.configure(args)
# Start server
server.start_webserver(options=args, protocol=_PVCatalystManager)
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(description="ParaView/Web Parallel Sphere web-application")
# Add default arguments
server.add_arguments(parser)
# Add local arguments
parser.add_argument("--data-dir", default=os.getcwd(), help="path to data directory to list", dest="path")
parser.add_argument("--ds-host", default=None, help="Hostname to connect to for DataServer", dest="dsHost")
parser.add_argument("--ds-port", default=11111, type=int, help="Port number to connect to for DataServer", dest="dsPort")
parser.add_argument("--rs-host", default=None, help="Hostname to connect to for RenderServer", dest="rsHost")
parser.add_argument("--rs-port", default=11111, type=int, help="Port number to connect to for RenderServer", dest="rsPort")
parser.add_argument("--text", default="", help="2D text to be shown", dest="text")
# Exctract arguments
args = parser.parse_args()
# Configure our current application
_Sphere.authKey = args.authKey
_Sphere.dataDir = args.path
_Sphere.dsHost = args.dsHost
_Sphere.dsPort = args.dsPort
_Sphere.rsHost = args.rsHost
_Sphere.rsPort = args.rsPort
_Sphere.text = args.text
# Start server
server.start_webserver(options=args, protocol=_Sphere)
def allreduce(kvs):
import os
os.environ["PMI_PORT"] = kvs["PMI_PORT"]
os.environ["PMI_ID"] = str(kvs["PMI_ID"])
os.environ["PV_ALLOW_BATCH_INTERACTION"] = "1"
os.environ["DISPLAY"] = ":0"
import paraview
paraview.options.batch = True
from vtk.vtkPVVTKExtensionsCore import vtkDistributedTrivialProducer
from vtk.vtkFiltersSources import vtkSphereSource
source = vtkSphereSource()
source.SetCenter(kvs['Center'])
source.SetPhiResolution(kvs['Resolution'])
source.SetThetaResolution(kvs['Resolution'])
source.Update()
vtkDistributedTrivialProducer.SetGlobalOutput('Spark', source.GetOutput())
from vtk.vtkPVClientServerCoreCore import vtkProcessModule
from paraview import simple
from paraview.web import wamp as pv_wamp
from paraview.web import protocols as pv_protocols
from vtk.web import server
pm = vtkProcessModule.GetProcessModule()
class Options(object):
debug = False
nosignalhandlers = True
host = 'localhost'
port = 9753
timeout = 300
content = '/data/sebastien/SparkMPI/runtime/visualizer/dist'
forceFlush = False
sslKey = ''
sslCert = ''
ws = 'ws'
lp = 'lp'
hp = 'hp'
nows = False
nobws = False
nolp = False
fsEndpoints = ''
uploadPath = None
testScriptPath = ''
baselineImgDir = ''
useBrowser = 'nobrowser'
tmpDirectory = '.'
testImgFile = ''
class _VisualizerServer(pv_wamp.PVServerProtocol):
dataDir = '/data'
groupRegex = "[0-9]+\\.[0-9]+\\.|[0-9]+\\."
excludeRegex = "^\\.|~$|^\\$"
allReaders = True
viewportScale=1.0
viewportMaxWidth=2560
viewportMaxHeight=1440
def initialize(self):
# Bring used components
self.registerVtkWebProtocol(pv_protocols.ParaViewWebFileListing(_VisualizerServer.dataDir, "Home", _VisualizerServer.excludeRegex, _VisualizerServer.groupRegex))
self.registerVtkWebProtocol(pv_protocols.ParaViewWebProxyManager(baseDir=_VisualizerServer.dataDir, allowUnconfiguredReaders=_VisualizerServer.allReaders))
self.registerVtkWebProtocol(pv_protocols.ParaViewWebColorManager())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebMouseHandler())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebViewPort(_VisualizerServer.viewportScale, _VisualizerServer.viewportMaxWidth, _VisualizerServer.viewportMaxHeight))
self.registerVtkWebProtocol(pv_protocols.ParaViewWebViewPortImageDelivery())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebViewPortGeometryDelivery())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebTimeHandler())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebSelectionHandler())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebWidgetManager())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebKeyValuePairStore())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebSaveData(baseSavePath=_VisualizerServer.dataDir))
# Disable interactor-based render calls
simple.GetRenderView().EnableRenderOnInteraction = 0
simple.GetRenderView().Background = [0,0,0]
# Update interaction mode
pxm = simple.servermanager.ProxyManager()
interactionProxy = pxm.GetProxy('settings', 'RenderViewInteractionSettings')
interactionProxy.Camera3DManipulators = ['Rotate', 'Pan', 'Zoom', 'Pan', 'Roll', 'Pan', 'Zoom', 'Rotate', 'Zoom']
args = Options()
if pm.GetPartitionId() == 0:
producer = simple.DistributedTrivialProducer()
producer.UpdateDataset = ''
producer.UpdateDataset = 'Spark'
server.start_webserver(options=args, protocol=_VisualizerServer)
pm.GetGlobalController().TriggerBreakRMIs()
out = {
'rank' : pm.GetPartitionId(),
'size': pm.GetNumberOfLocalPartitions()
}
return out
self.renderer.AddActor(self.actor)
self.renderer.SetBackground(1, 1, 1)
# VTK Web application specific
_WebMolecule.view = self.window
self.Application.GetObjectIdMap().SetActiveObject(
"VIEW", self.window)
# =============================================================================
# Main: Parse args and start server
# =============================================================================
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(
description="VTK/Web Molecule web-application")
# Add default arguments
server.add_arguments(parser)
# Exctract arguments
args = parser.parse_args()
# Configure our current application
#_WebMolecule.authKey = args.authKey
# Start server
server.start_webserver(options=args, protocol=_WebMolecule)
self.updateSecret(_WebFileBrowser.authKey)
# =============================================================================
# Main: Parse args and start server
# =============================================================================
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(
description="VTK/Web FileBrowser web-application")
# Add default arguments
server.add_arguments(parser)
# Add local arguments
parser.add_argument("--data-dir",
help="Base directory to list",
dest="basedir",
default=".")
# Exctract arguments
args = parser.parse_args()
# Configure our current application
_WebFileBrowser.authKey = args.authKey
_WebFileBrowser.basedir = args.basedir
# Start server
server.start_webserver(options=args, protocol=_WebFileBrowser)
from vtk.web import server
# Configure our current application
pv_web_visualizer._PipelineManager.authKey = 'paraviewweb-secret'
pv_web_visualizer._PipelineManager.dataDir = '.'
# Setup static args
class TestArgs:
pass
args = TestArgs()
args.host = 'localhost'
args.port = 8081
args.debug = 1
args.timeout = 10
args.content = ''
args.nosignalhandlers = False
args.authKey = 'vtkweb-secret'
args.forceFlush = False
args.testScriptPath = ''
args.baselineImgDir = ''
args.path = '.'
args.file = None
args.dsHost = None
args.dsPort = 11111
args.rsHost = None
args.rsPort = 11111
# Start server
server.start_webserver(options=args, protocol=pv_web_visualizer._PipelineManager)
# VTK Web application specific
_PhylogeneticTree.view = view.GetRenderWindow()
self.Application.GetObjectIdMap().SetActiveObject("VIEW", view.GetRenderWindow())
# =============================================================================
# Main: Parse args and start server
# =============================================================================
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(description="VTK/Web Tree web-application")
# Add default arguments
server.add_arguments(parser)
# Add local arguments
parser.add_argument("--tree", help="path to phy tree file", dest="tree")
parser.add_argument("--table", help="path to csv file", dest="table")
# Exctract arguments
args = parser.parse_args()
# Configure our current application
_PhylogeneticTree.authKey = args.authKey
_PhylogeneticTree.treeFilePath = args.tree
_PhylogeneticTree.csvFilePath = args.table
# Start server
server.start_webserver(options=args, protocol=_PhylogeneticTree)
basePath = '.'
uploadPath = '.'
def __init__(self, *arg, **kw):
wamp.ServerProtocol.__init__(self, *arg, **kw)
self.traceback_app = True
def initialize(self):
# intialize protocols
self.registerVtkWebProtocol(protocols.MouseHandler())
self.registerVtkWebProtocol(protocols.ViewPort())
self.registerVtkWebProtocol(protocols.RemoteRender())
self.registerVtkWebProtocol(
protocols.FileBrowser(self.uploadPath, "Home"))
self.registerVtkWebProtocol(protocols.FileLoader(self.uploadPath))
self.registerVtkWebProtocol(protocols.FileFinder(self.uploadPath))
self.registerVtkWebProtocol(protocols.ViewportDeleter())
self.registerVtkWebProtocol(Visualizer())
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description='CDATWeb visualization server')
server.add_arguments(parser)
args = parser.parse_args()
CDATWebVisualizer.uploadPath = args.uploadPath
print("CDATWeb Visualization server initializing")
server.start_webserver(options=args, protocol=CDATWebVisualizer)
if oldTime != self.View.ViewTime:
self.publish("vtk.event.probe.data.changed", True)
print 'publish b'
return True
return False
# =============================================================================
# Main: Parse args and start server
# =============================================================================
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(description="ParaView Web data.prober")
# Add default arguments
server.add_arguments(parser)
# Add local arguments
parser.add_argument("--data-dir", help="path to data directory", dest="path")
# Exctract arguments
args = parser.parse_args()
# Configure our current application
_DataProber.DataPath = args.path
_DataProber.setupApplication()
_DataProber.authKey = args.authKey
# Start server
server.start_webserver(options=args, protocol=_DataProber)
simple.GetRenderView().Background2 = [0, 0, 0]
# Update interaction mode
pxm = simple.servermanager.ProxyManager()
interactionProxy = pxm.GetProxy('settings',
'RenderViewInteractionSettings')
interactionProxy.Camera3DManipulators = [
'Rotate', 'Pan', 'Zoom', 'Pan', 'Roll', 'Pan', 'Zoom', 'Rotate',
'Zoom'
]
# =============================================================================
# Main: Parse args and start server
# =============================================================================
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(description="LightViz")
# Add arguments
server.add_arguments(parser)
LightVizServer.add_arguments(parser)
args = parser.parse_args()
LightVizServer.configure(args)
args.fsEndpoints = 'ds=' + args.data
# Start server
server.start_webserver(options=args, protocol=LightVizServer)
self.registerVtkWebProtocol(pv_protocols.ParaViewWebViewPortImageDelivery())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebViewPortGeometryDelivery())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebTimeHandler())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebRemoteConnection())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebFileManager(_PipelineManager.dataDir))
self.registerVtkWebProtocol(pv_protocols.ParaViewWebSelectionHandler())
# Update authentication key to use
self.updateSecret(_PipelineManager.authKey)
# =============================================================================
# Main: Parse args and start server
# =============================================================================
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(description="ParaView/Web Pipeline Manager web-application")
# Add arguments
server.add_arguments(parser)
_PipelineManager.add_arguments(parser)
# Exctract arguments
args = parser.parse_args()
# Configure our current application
_PipelineManager.configure(args)
# Start server
server.start_webserver(options=args, protocol=_PipelineManager)
@exportRpc('toggle.bg.color')
def changeBgColor(self):
# FIXME when we get the right face names
bgColor = self.view.Background[0]
bgColor = bgColor + 0.5
if bgColor > 1.0:
bgColor = 0
self.view.Background = [bgColor, bgColor, bgColor]
if bgColor == 1.0:
self.outline.AmbientColor = [0.0, 0.0, 0.0]
else:
self.outline.AmbientColor = [1.0, 1.0, 1.0]
# =============================================================================
# Main: Parse args and start server
# =============================================================================
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(description="Mesh Viewer")
# Add arguments
server.add_arguments(parser)
_MeshViewer.add_arguments(parser)
args = parser.parse_args()
_MeshViewer.configure(args)
# Start server
server.start_webserver(options=args, protocol=_MeshViewer)
def processPartition(idx, iterator):
print('==============> processPartition %d' % idx)
import os
os.environ["PMI_PORT"] = pmi_port
os.environ["PMI_ID"] = str(idx)
os.environ["PV_ALLOW_BATCH_INTERACTION"] = "1"
os.environ["DISPLAY"] = ":0"
import paraview
paraview.options.batch = True
from vtk.vtkCommonExecutionModel import vtkTrivialProducer
from vtk.vtkPVVTKExtensionsCore import vtkDistributedTrivialProducer
from vtk.vtkCommonCore import vtkIntArray, vtkUnsignedCharArray
from vtk.vtkCommonDataModel import vtkImageData, vtkPointData, vtkCellData
offset = 0
for i in range(idx):
offset += zSizes[i] * sliceSize
size = zSizes[idx] * sliceSize
maxIdx = 0
minIdx = globalMaxIndex
data = vtkIntArray()
data.SetName('scalar')
data.SetNumberOfTuples(size)
data.Fill(0)
for row in iterator:
#print('pid: %d - %d | %d' % (idx, row[0], row[1]))
data.SetValue(row[0] - offset, row[1])
maxIdx = row[0] if row[0] > maxIdx else maxIdx
minIdx = row[0] if row[0] < minIdx else minIdx
print('pid %d - min: %d - max: %d' % (idx, minIdx, maxIdx))
dataset = vtkImageData()
minZ = 0
maxZ = 0
for i in range(idx + 1):
minZ = maxZ
maxZ += zSizes[i]
print('%d extent %d, %d' % (idx, minZ, maxZ - 1))
dataset.SetExtent(0, sizeX - 1, 0, sizeY - 1, minZ, maxZ - 1)
dataset.GetPointData().SetScalars(data)
print('%d - (%d, %d) - offset %d - size %d - dimension %d, %d, %d ' %
(idx, minIdx - offset, maxIdx - offset, offset, size, sizeX, sizeY,
zSizes[idx]))
vtkDistributedTrivialProducer.SetGlobalOutput('Spark', dataset)
from vtk.vtkPVClientServerCoreCore import vtkProcessModule
from paraview import simple
from paraview.web import wamp as pv_wamp
from paraview.web import protocols as pv_protocols
from vtk.web import server
pm = vtkProcessModule.GetProcessModule()
class Options(object):
debug = False
nosignalhandlers = True
host = 'localhost'
port = 9753
timeout = 300
content = '/data/sebastien/SparkMPI/runtime/visualizer/dist'
forceFlush = False
sslKey = ''
sslCert = ''
ws = 'ws'
lp = 'lp'
hp = 'hp'
nows = False
nobws = False
nolp = False
fsEndpoints = ''
uploadPath = None
testScriptPath = ''
baselineImgDir = ''
useBrowser = 'nobrowser'
tmpDirectory = '.'
testImgFile = ''
class _VisualizerServer(pv_wamp.PVServerProtocol):
dataDir = '/data'
groupRegex = "[0-9]+\\.[0-9]+\\.|[0-9]+\\."
excludeRegex = "^\\.|~$|^\\$"
allReaders = True
viewportScale = 1.0
viewportMaxWidth = 2560
viewportMaxHeight = 1440
def initialize(self):
# Bring used components
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebFileListing(
_VisualizerServer.dataDir, "Home",
_VisualizerServer.excludeRegex,
_VisualizerServer.groupRegex))
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebProxyManager(
baseDir=_VisualizerServer.dataDir,
allowUnconfiguredReaders=_VisualizerServer.allReaders))
self.registerVtkWebProtocol(pv_protocols.ParaViewWebColorManager())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebMouseHandler())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebViewPort(
_VisualizerServer.viewportScale,
_VisualizerServer.viewportMaxWidth,
_VisualizerServer.viewportMaxHeight))
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebViewPortImageDelivery())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebViewPortGeometryDelivery())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebTimeHandler())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebSelectionHandler())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebWidgetManager())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebKeyValuePairStore())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebSaveData(
baseSavePath=_VisualizerServer.dataDir))
# Disable interactor-based render calls
simple.GetRenderView().EnableRenderOnInteraction = 0
simple.GetRenderView().Background = [0, 0, 0]
# Update interaction mode
pxm = simple.servermanager.ProxyManager()
interactionProxy = pxm.GetProxy('settings',
'RenderViewInteractionSettings')
interactionProxy.Camera3DManipulators = [
'Rotate', 'Pan', 'Zoom', 'Pan', 'Roll', 'Pan', 'Zoom',
'Rotate', 'Zoom'
]
args = Options()
if pm.GetPartitionId() == 0:
producer = simple.DistributedTrivialProducer()
producer.UpdateDataset = ''
producer.UpdateDataset = 'Spark'
producer.WholeExtent = [0, 99, 0, 215, 0, 260]
server.start_webserver(options=args, protocol=_VisualizerServer)
pm.GetGlobalController().TriggerBreakRMIs()
yield (idx, targetPartition)
try:
usermod = imp.load_source("usermod", userfile)
except IOError:
print >> sys.stderr, "error: could not open file '%s'" % (userfile)
sys.exit(2)
except ImportError as e:
print >> sys.stderr, "error: could not import module '%s'" % (userfile)
print >> sys.stderr, "({})".format(e)
sys.exit(2)
# Create argument parser
parser = argparse.ArgumentParser(description="Tangelo/VTKWeb application")
# Add default arguments
server.add_arguments(parser)
# Add local arguments, if any are specified in the user module.
if "add_arguments" in usermod.__dict__:
usermod.add_arguments(parser)
# Extract arguments (dropping the "usermodule" argument first).
del sys.argv[1]
args = parser.parse_args()
# Configure our current application
VTKWebApp = VTKWebAppProtocol(args, usermod)
VTKWebApp.authKey = args.authKey
# Start server
server.start_webserver(options=args, protocol=VTKWebApp)
# Add default arguments
server.add_arguments(parser)
# Add local arguments
parser.add_argument("--data-dir",
default=os.getcwd(),
help="path to ParaView data directory",
dest="path")
parser.add_argument("--echo",
default="",
help="A string that will be available through echo protocol",
dest="echoString")
parser.add_argument("--proxy-file",
default=None,
type=str,
help="Path to a file containing the list of allowed filter and source proxies",
dest="proxyFile")
# Exctract arguments
args = parser.parse_args()
# Configure our current application
_TestApp.dataDir = args.path
_TestApp.authKey = args.authKey
_TestApp.echoStr = args.echoString
_TestApp.proxyFile = args.proxyFile
# Start server
server.start_webserver(options=args, protocol=_TestApp)
self.registerVtkWebProtocol(lv_protocols.LightVizSlice(datasetManager, clipManager))
self.registerVtkWebProtocol(lv_protocols.LightVizMultiSlice(datasetManager, clipManager))
self.registerVtkWebProtocol(lv_protocols.LightVizStreamline(datasetManager))
self.registerVtkWebProtocol(lv_protocols.LightVizThreshold(datasetManager, clipManager))
self.registerVtkWebProtocol(lv_protocols.LightVizVolume(datasetManager, clipManager))
# Update authentication key to use
self.updateSecret(LightVizServer.authKey)
# Disable interactor-based render calls
simple.GetRenderView().EnableRenderOnInteraction = 0
simple.GetRenderView().Background = [0,0,0]
simple.GetRenderView().Background2 = [0,0,0]
# =============================================================================
# Main: Parse args and start server
# =============================================================================
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(description="LightViz")
# Add arguments
server.add_arguments(parser)
LightVizServer.add_arguments(parser)
args = parser.parse_args()
LightVizServer.configure(args)
# Start server
server.start_webserver(options=args, protocol=LightVizServer)
def start():
args = WebArguments('%s/www' % build_path)
TestProtocol.updateArguments(args)
server.start_webserver(options=args, protocol=TestProtocol)
renderer.AddActor(actor)
renderer.ResetCamera()
renderWindow.Render()
# VTK Web application specific
_WebCone.view = renderWindow
self.Application.GetObjectIdMap().SetActiveObject(
"VIEW", renderWindow)
# =============================================================================
# Main: Parse args and start server
# =============================================================================
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(
description="VTK/Web Cone web-application")
# Add default arguments
server.add_arguments(parser)
# Exctract arguments
args = parser.parse_args()
# Configure our current application
_WebCone.authKey = args.authKey
# Start server
server.start_webserver(options=args, protocol=_WebCone)
mapper.SetInputConnection(cone.GetOutputPort())
actor.SetMapper(mapper)
renderer.AddActor(actor)
renderer.ResetCamera()
renderWindow.Render()
# VTK Web application specific
_WebCone.view = renderWindow
self.Application.GetObjectIdMap().SetActiveObject("VIEW", renderWindow)
# =============================================================================
# Main: Parse args and start server
# =============================================================================
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(description="VTK/Web Cone web-application")
# Add default arguments
server.add_arguments(parser)
# Exctract arguments
args = parser.parse_args()
# Configure our current application
_WebCone.authKey = args.authKey
# Start server
server.start_webserver(options=args, protocol=_WebCone)
simple.Hide(self.srcObj)
simple.SetActiveSource(self.subgrid)
simple.Render()
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description="Midas+ParaViewWeb application")
server.add_arguments(parser)
parser.add_argument("--data-dir",
default=os.getcwd(),
help="path to data directory",
dest="path")
parser.add_argument("--width",
default=575,
help="width of the render window",
dest="width")
parser.add_argument("--height",
default=575,
help="height of the render window",
dest="height")
args = parser.parse_args()
dataPath = args.path
authKey = args.authKey
width = args.width
height = args.height
initView(width, height)
server.start_webserver(options=args, protocol=MidasApp)
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebViewPortGeometryDelivery())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebTimeHandler())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebSelectionHandler())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebWidgetManager())
# Update authentication key to use
self.updateSecret(_VisualizerServer.authKey)
# Disable interactor-based render calls
simple.GetRenderView().GetRenderWindow().GetInteractor(
).RenderCallsEnabledOff()
# =============================================================================
# Main: Parse args and start server
# =============================================================================
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(description="ParaView Web Visualizer")
# Add arguments
server.add_arguments(parser)
_VisualizerServer.add_arguments(parser)
args = parser.parse_args()
_VisualizerServer.configure(args)
# Start server
server.start_webserver(options=args, protocol=_VisualizerServer)
return True
return False
# =============================================================================
# Main: Parse args and start server
# =============================================================================
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(description="ParaView Web data.prober")
# Add default arguments
server.add_arguments(parser)
# Add local arguments
parser.add_argument("--data-dir",
help="path to data directory",
dest="path")
# Exctract arguments
args = parser.parse_args()
# Configure our current application
_DataProber.DataPath = args.path
_DataProber.setupApplication()
_DataProber.authKey = args.authKey
# Start server
server.start_webserver(options=args, protocol=_DataProber)
def processPartition(idx, iterator):
import os
os.environ["PMI_PORT"] = pmi_port
os.environ["PMI_ID"] = str(idx)
os.environ["PV_ALLOW_BATCH_INTERACTION"] = "1"
os.environ["DISPLAY"] = ":0"
import paraview
paraview.options.batch = True
from vtk.vtkPVVTKExtensionsCore import vtkDistributedTrivialProducer
from vtk.vtkCommonCore import vtkIntArray, vtkPoints
from vtk.vtkCommonDataModel import vtkPolyData, vtkPointData, vtkCellArray
pointData = vtkIntArray()
pointData.SetName('scalar')
pointData.Allocate(maxIndex)
partData = vtkIntArray()
partData.SetName('pid')
partData.Allocate(maxIndex)
points = vtkPoints()
points.Allocate(maxIndex)
for row in iterator:
coord = idxToCoord(row[0])
points.InsertNextPoint(coord[0], coord[1], coord[2])
pointData.InsertNextTuple1(row[1])
partData.InsertNextTuple1(idx)
cells = vtkCellArray()
cells.Allocate(points.GetNumberOfPoints() + 1)
cells.InsertNextCell(points.GetNumberOfPoints())
for i in range(points.GetNumberOfPoints()):
cells.InsertCellPoint(i)
dataset = vtkPolyData()
dataset.SetPoints(points)
dataset.SetVerts(cells)
dataset.GetPointData().AddArray(pointData)
dataset.GetPointData().SetScalars(partData)
vtkDistributedTrivialProducer.SetGlobalOutput('Spark', dataset)
from vtk.vtkPVClientServerCoreCore import vtkProcessModule
from paraview import simple
from paraview.web import wamp as pv_wamp
from paraview.web import protocols as pv_protocols
from vtk.web import server
pm = vtkProcessModule.GetProcessModule()
class Options(object):
debug = False
nosignalhandlers = True
host = 'localhost'
port = 9753
timeout = 300
content = '/data/sebastien/SparkMPI/runtime/visualizer/dist'
forceFlush = False
sslKey = ''
sslCert = ''
ws = 'ws'
lp = 'lp'
hp = 'hp'
nows = False
nobws = False
nolp = False
fsEndpoints = ''
uploadPath = None
testScriptPath = ''
baselineImgDir = ''
useBrowser = 'nobrowser'
tmpDirectory = '.'
testImgFile = ''
class _VisualizerServer(pv_wamp.PVServerProtocol):
dataDir = '/data'
groupRegex = "[0-9]+\\.[0-9]+\\.|[0-9]+\\."
excludeRegex = "^\\.|~$|^\\$"
allReaders = True
viewportScale = 1.0
viewportMaxWidth = 2560
viewportMaxHeight = 1440
def initialize(self):
# Bring used components
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebFileListing(
_VisualizerServer.dataDir, "Home",
_VisualizerServer.excludeRegex,
_VisualizerServer.groupRegex))
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebProxyManager(
baseDir=_VisualizerServer.dataDir,
allowUnconfiguredReaders=_VisualizerServer.allReaders))
self.registerVtkWebProtocol(pv_protocols.ParaViewWebColorManager())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebMouseHandler())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebViewPort(
_VisualizerServer.viewportScale,
_VisualizerServer.viewportMaxWidth,
_VisualizerServer.viewportMaxHeight))
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebViewPortImageDelivery())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebViewPortGeometryDelivery())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebTimeHandler())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebSelectionHandler())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebWidgetManager())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebKeyValuePairStore())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebSaveData(
baseSavePath=_VisualizerServer.dataDir))
# Disable interactor-based render calls
simple.GetRenderView().EnableRenderOnInteraction = 0
simple.GetRenderView().Background = [0, 0, 0]
# Update interaction mode
pxm = simple.servermanager.ProxyManager()
interactionProxy = pxm.GetProxy('settings',
'RenderViewInteractionSettings')
interactionProxy.Camera3DManipulators = [
'Rotate', 'Pan', 'Zoom', 'Pan', 'Roll', 'Pan', 'Zoom',
'Rotate', 'Zoom'
]
args = Options()
if pm.GetPartitionId() == 0:
producer = simple.DistributedTrivialProducer()
producer.UpdateDataset = ''
producer.UpdateDataset = 'Spark'
server.start_webserver(options=args, protocol=_VisualizerServer)
pm.GetGlobalController().TriggerBreakRMIs()
yield (idx, targetPartition)
r = requests.get(item_url, headers=self._headers)
self._check_status(r)
dest_path = os.path.join(_ResultViewer.dataDir, files[0]['name'])
os.makedirs(os.path.dirname(dest_path))
with open(dest_path, 'w') as fp:
fp.write(r.content)
elif len(files) > 1:
# Download the item in zip format
item_url = '%s/item/%s/download' % (_ResultViewer.url, item_id)
r = requests.get(item_url, headers=self._headers)
self._check_status(r)
files = zipfile.ZipFile(io.BytesIO(r.content))
dest_path = os.path.join(_ResultViewer.dataDir)
files.extractall(dest_path)
# =============================================================================
# Main: Parse args and start server
# =============================================================================
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(description="Mesh Viewer")
# Add arguments
server.add_arguments(parser)
_ResultViewer.add_arguments(parser)
args = parser.parse_args()
_ResultViewer.configure(args)
# Start server
server.start_webserver(options=args, protocol=_ResultViewer)
def _start_web_server():
server.start_webserver(options=ParaViewIPython.webArguments,
protocol=ParaViewIPython.webProtocol)
from paraview import simple
simple.Disconnect()
ParaViewIPython.localController.TriggerBreakRMIs()
print 'Layout Strategy = Community 2D'
_WebGraph.view.SetLayoutStrategyToCommunity2D()
_WebGraph.view.ResetCamera()
_WebGraph.view.Render()
# =============================================================================
# Main: Parse args and start server
# =============================================================================
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(description="VTK/Web Graph web-application")
# Add default arguments
server.add_arguments(parser)
# Add local arguments
parser.add_argument("--vertices", help="Number of vertices used to generate graph", dest="vertices", type=int, default=1000)
parser.add_argument("--edges", help="Number of edges used to generate graph", dest="edges", type=int, default=400)
# Exctract arguments
args = parser.parse_args()
# Configure our current application
_WebGraph.authKey = args.authKey
_WebGraph.vertices = args.vertices
_WebGraph.edges = args.edges
# Start server
server.start_webserver(options=args, protocol=_WebGraph)
def visualization(partitionId, iterator):
# Setup MPI context
import os
os.environ["PMI_PORT"] = pmi_port
os.environ["PMI_ID"] = str(partitionId)
os.environ["PV_ALLOW_BATCH_INTERACTION"] = "1"
os.environ["DISPLAY"] = ":0"
# Extract iOffset
iOffset = 0
localSizeX = getMPISizeX(partitionId)
size = localSizeX * sizeY * sizeY
for i in range(partitionId):
iOffset += getMPISizeX(i)
# Copy data from iterator into data chunk
t0 = time.time()
count = 0
dataChunk = np.arange(size, dtype=float)
for item in iterator:
count += 1
globalIndex = item[0]
pixelValue = item[1]
# print('%d # %d: %f' % (partitionId, globalIndex, pixelValue))
ijk = _ijk(globalIndex)
ijk[0] -= iOffset
destIdx = ijk[0] + (ijk[1] * localSizeX) + (ijk[2] * localSizeX *
sizeY)
dataChunk[destIdx] = pixelValue
t1 = time.time()
print('%d # MPI Gather %s | %d' % (partitionId, str(t1 - t0), count))
t0 = t1
# Configure Paraview for MPI
import paraview
paraview.options.batch = True
from vtk.vtkPVVTKExtensionsCore import vtkDistributedTrivialProducer
from vtk.vtkCommonCore import vtkIntArray, vtkUnsignedCharArray, vtkFloatArray
from vtk.vtkCommonDataModel import vtkImageData, vtkPointData
# -------------------------------------------------------------------------
# Data access helper
# -------------------------------------------------------------------------
def createSlice():
size = sizeY * sizeY
array = np.arange(size, dtype=float)
return array
def getSideSlice(offset, xSize):
size = sizeY * sizeY
slice = np.arange(size, dtype=float)
for i in range(size):
slice[i] = dataChunk[int(offset + (i * xSize))]
return slice
# -------------------------------------------------------------------------
# Add ghost points from neighbors
# -------------------------------------------------------------------------
from mpi4py import MPI
comm = MPI.COMM_WORLD
remoteLowerSlice = None
remoteUpperSlice = None
if partitionId + 1 < nbMPIPartition:
# Share upper slice
remoteUpperSlice = createSlice()
localUpperSlice = getSideSlice(localSizeX - 1, localSizeX)
comm.Sendrecv(localUpperSlice, (partitionId + 1),
(2 * partitionId + 1), remoteUpperSlice,
(partitionId + 1), (2 * partitionId))
if partitionId > 0:
# Share lower slice
remoteLowerSlice = createSlice()
localLowerSlice = getSideSlice(0, localSizeX)
comm.Sendrecv(localLowerSlice, (partitionId - 1),
(2 * (partitionId - 1)), remoteLowerSlice,
(partitionId - 1), (2 * (partitionId - 1) + 1))
t1 = time.time()
print('%d # MPI share %s | ' % (partitionId, str(t1 - t0)))
t0 = t1
# -------------------------------------------------------------------------
dataset = vtkImageData()
minX = 0
maxX = 0
for i in range(partitionId + 1):
minX = maxX
maxX += getMPISizeX(i)
# -------------------------------------------------------------------------
# Add slice(s) to data
# -------------------------------------------------------------------------
arrayWithSlices = vtkFloatArray()
arrayWithSlices.SetName('Scalars')
if remoteLowerSlice != None and remoteUpperSlice != None:
# Add both slices
minX -= 1
maxX += 1
localSizeX = maxX - minX
newSize = localSizeX * sizeY * sizeY
arrayWithSlices.SetNumberOfTuples(newSize)
localOffset = 0
for i in range(newSize):
if i % localSizeX == 0:
arrayWithSlices.SetTuple1(i, remoteLowerSlice[i / localSizeX])
elif (i + 1) % localSizeX == 0:
arrayWithSlices.SetTuple1(
i, remoteUpperSlice[((i + 1) / localSizeX) - 1])
else:
arrayWithSlices.SetTuple1(i, dataChunk[localOffset])
localOffset += 1
elif remoteLowerSlice != None:
# Add lower slice
minX -= 1
localSizeX = maxX - minX
newSize = localSizeX * sizeY * sizeY
arrayWithSlices.SetNumberOfTuples(newSize)
localOffset = 0
for i in range(newSize):
if i % localSizeX == 0:
arrayWithSlices.SetTuple1(i, remoteLowerSlice[i / localSizeX])
else:
arrayWithSlices.SetTuple1(i, dataChunk[localOffset])
localOffset += 1
elif remoteUpperSlice != None:
# Add upper slice
maxX += 1
localSizeX = maxX - minX
newSize = localSizeX * sizeY * sizeY
arrayWithSlices.SetNumberOfTuples(newSize)
localOffset = 0
for i in range(newSize):
if (i + 1) % localSizeX == 0:
arrayWithSlices.SetTuple1(
i, remoteUpperSlice[((i + 1) / localSizeX) - 1])
else:
arrayWithSlices.SetTuple1(i, dataChunk[localOffset])
localOffset += 1
dataset.SetExtent(minX, maxX - 1, 0, sizeY - 1, 0, sizeY - 1)
dataset.GetPointData().SetScalars(arrayWithSlices)
t1 = time.time()
print('%d # build resutling image data %s | ' %
(partitionId, str(t1 - t0)))
t0 = t1
# -------------------------------------------------------------------------
vtkDistributedTrivialProducer.SetGlobalOutput('Spark', dataset)
from vtk.vtkPVClientServerCoreCore import vtkProcessModule
from paraview import simple
from vtk.web import server
from paraview.web import wamp as pv_wamp
from paraview.web import protocols as pv_protocols
class _VisualizerServer(pv_wamp.PVServerProtocol):
dataDir = '/data'
groupRegex = "[0-9]+\\.[0-9]+\\.|[0-9]+\\."
excludeRegex = "^\\.|~$|^\\$"
allReaders = True
viewportScale = 1.0
viewportMaxWidth = 2560
viewportMaxHeight = 1440
def initialize(self):
# Bring used components
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebFileListing(
_VisualizerServer.dataDir, "Home",
_VisualizerServer.excludeRegex,
_VisualizerServer.groupRegex))
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebProxyManager(
baseDir=_VisualizerServer.dataDir,
allowUnconfiguredReaders=_VisualizerServer.allReaders))
self.registerVtkWebProtocol(pv_protocols.ParaViewWebColorManager())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebMouseHandler())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebViewPort(
_VisualizerServer.viewportScale,
_VisualizerServer.viewportMaxWidth,
_VisualizerServer.viewportMaxHeight))
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebViewPortImageDelivery())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebViewPortGeometryDelivery())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebTimeHandler())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebSelectionHandler())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebWidgetManager())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebKeyValuePairStore())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebSaveData(
baseSavePath=_VisualizerServer.dataDir))
# Disable interactor-based render calls
simple.GetRenderView().EnableRenderOnInteraction = 0
simple.GetRenderView().Background = [0, 0, 0]
# Update interaction mode
pxm = simple.servermanager.ProxyManager()
interactionProxy = pxm.GetProxy('settings',
'RenderViewInteractionSettings')
interactionProxy.Camera3DManipulators = [
'Rotate', 'Pan', 'Zoom', 'Pan', 'Roll', 'Pan', 'Zoom',
'Rotate', 'Zoom'
]
pm = vtkProcessModule.GetProcessModule()
# -------------------------------------------------------------------------
print('%d # > Start visualization - %s | ' %
(partitionId, str(datetime.now())))
# -------------------------------------------------------------------------
args = Options()
if pm.GetPartitionId() == 0:
print('%d # ==> %d' % (partitionId, pm.GetPartitionId()))
producer = simple.DistributedTrivialProducer()
producer.UpdateDataset = ''
producer.UpdateDataset = 'Spark'
producer.WholeExtent = [0, sizeX - 1, 0, sizeY - 1, 0, sizeY - 1]
server.start_webserver(options=args, protocol=_VisualizerServer)
pm.GetGlobalController().TriggerBreakRMIs()
print('%d # < Stop visualization - %s | ' %
(partitionId, str(datetime.now())))
yield (partitionId, nbMPIPartition)
def processPartition(idx, iterator):
print('### Start data processing for %d - %s | ' %
(idx, str(datetime.now())))
import os
os.environ["PMI_PORT"] = pmi_port
os.environ["PMI_ID"] = str(idx)
os.environ["PV_ALLOW_BATCH_INTERACTION"] = "1"
os.environ["DISPLAY"] = ":0"
import paraview
paraview.options.batch = True
from vtk.vtkCommonExecutionModel import vtkTrivialProducer
from vtk.vtkPVVTKExtensionsCore import vtkDistributedTrivialProducer
from vtk.vtkCommonCore import vtkIntArray, vtkUnsignedCharArray
from vtk.vtkCommonDataModel import vtkImageData, vtkPointData, vtkCellData
iOffset = 0
for i in range(idx):
iOffset += xSizes[i]
size = xSizes[idx] * sizeY * sizeZ
# -------------------------------------------------------------------------
# Gather data chunk
# -------------------------------------------------------------------------
dataChunk = vtkIntArray()
dataChunk.SetName('scalar')
dataChunk.SetNumberOfTuples(size)
dataChunk.Fill(0)
t0 = time.time()
count = 0
for row in iterator:
count += 1
coords = idxToCoord(row[0])
originCoords = '[%d, %d, %d]' % (coords[0], coords[1], coords[2])
coords[0] -= iOffset
destIdx = coords[0] + (coords[1] * xSizes[idx]) + (coords[2] *
xSizes[idx] * sizeY)
dataChunk.SetValue(destIdx, row[1])
t1 = time.time()
print('%d # Gather %s | ' % (idx, str(t1 - t0)))
t0 = t1
# -------------------------------------------------------------------------
# Reshape data into 3D Fortran array ordering
# -------------------------------------------------------------------------
npDataChunk = numpy_support.vtk_to_numpy(dataChunk)
scalars_array3d = np.reshape(npDataChunk, (xSizes[idx], sizeY, sizeZ),
order='F')
t1 = time.time()
print('%d # Reshape %s | ' % (idx, str(t1 - t0)))
t0 = t1
# -------------------------------------------------------------------------
# Reconstruction helper
# -------------------------------------------------------------------------
def parallelRay(Nside, pixelWidth, angles, Nray, rayWidth):
# Suppress warning messages that pops up when dividing zeros
np.seterr(all='ignore')
Nproj = len(angles) # Number of projections
# Ray coordinates at 0 degrees.
offsets = np.linspace(-(Nray * 1.0 - 1) / 2,
(Nray * 1.0 - 1) / 2, Nray) * rayWidth
# Intersection lines/grid Coordinates
xgrid = np.linspace(-Nside * 0.5, Nside * 0.5, Nside + 1) * pixelWidth
ygrid = np.linspace(-Nside * 0.5, Nside * 0.5, Nside + 1) * pixelWidth
# Initialize vectors that contain matrix elements and corresponding
# row/column numbers
rows = np.zeros(2 * Nside * Nproj * Nray)
cols = np.zeros(2 * Nside * Nproj * Nray)
vals = np.zeros(2 * Nside * Nproj * Nray)
idxend = 0
for i in range(0, Nproj): # Loop over projection angles
ang = angles[i] * np.pi / 180.
# Points passed by rays at current angles
xrayRotated = np.cos(ang) * offsets
yrayRotated = np.sin(ang) * offsets
xrayRotated[np.abs(xrayRotated) < 1e-8] = 0
yrayRotated[np.abs(yrayRotated) < 1e-8] = 0
a = -np.sin(ang)
a = rmepsilon(a)
b = np.cos(ang)
b = rmepsilon(b)
for j in range(0, Nray): # Loop rays in current projection
#Ray: y = tx * x + intercept
t_xgrid = (xgrid - xrayRotated[j]) / a
y_xgrid = b * t_xgrid + yrayRotated[j]
t_ygrid = (ygrid - yrayRotated[j]) / b
x_ygrid = a * t_ygrid + xrayRotated[j]
# Collect all points
t_grid = np.append(t_xgrid, t_ygrid)
xx = np.append(xgrid, x_ygrid)
yy = np.append(y_xgrid, ygrid)
# Sort the coordinates according to intersection time
I = np.argsort(t_grid)
xx = xx[I]
yy = yy[I]
# Get rid of points that are outside the image grid
Ix = np.logical_and(xx >= -Nside / 2.0 * pixelWidth,
xx <= Nside / 2.0 * pixelWidth)
Iy = np.logical_and(yy >= -Nside / 2.0 * pixelWidth,
yy <= Nside / 2.0 * pixelWidth)
I = np.logical_and(Ix, Iy)
xx = xx[I]
yy = yy[I]
# If the ray pass through the image grid
if (xx.size != 0 and yy.size != 0):
# Get rid of double counted points
I = np.logical_and(
np.abs(np.diff(xx)) <= 1e-8,
np.abs(np.diff(yy)) <= 1e-8)
I2 = np.zeros(I.size + 1)
I2[0:-1] = I
xx = xx[np.logical_not(I2)]
yy = yy[np.logical_not(I2)]
# Calculate the length within the cell
length = np.sqrt(np.diff(xx)**2 + np.diff(yy)**2)
#Count number of cells the ray passes through
numvals = length.size
# Remove the rays that are on the boundary of the box in the
# top or to the right of the image grid
check1 = np.logical_and(
b == 0,
np.absolute(yrayRotated[j] - Nside / 2 * pixelWidth) <
1e-15)
check2 = np.logical_and(
a == 0,
np.absolute(xrayRotated[j] - Nside / 2 * pixelWidth) <
1e-15)
check = np.logical_not(np.logical_or(check1, check2))
if np.logical_and(numvals > 0, check):
# Calculate corresponding indices in measurement matrix
# First, calculate the mid points coord. between two
# adjacent grid points
midpoints_x = rmepsilon(0.5 * (xx[0:-1] + xx[1:]))
midpoints_y = rmepsilon(0.5 * (yy[0:-1] + yy[1:]))
#Calculate the pixel index for mid points
pixelIndicex = \
(np.floor(Nside / 2.0 - midpoints_y / pixelWidth)) * \
Nside + (np.floor(midpoints_x /
pixelWidth + Nside / 2.0))
# Create the indices to store the values to the measurement
# matrix
idxstart = idxend
idxend = idxstart + numvals
idx = np.arange(idxstart, idxend)
# Store row numbers, column numbers and values
rows[idx] = i * Nray + j
cols[idx] = pixelIndicex
vals[idx] = length
else:
print("Ray No. %d at %f degree is out of image grid!" %
(j + 1, angles[i]))
# Truncate excess zeros.
rows = rows[:idxend]
cols = cols[:idxend]
vals = vals[:idxend]
A = ss.coo_matrix((vals, (rows, cols)), shape=(Nray * Nproj, Nside**2))
return A
def rmepsilon(input):
if (input.size > 1):
input[np.abs(input) < 1e-10] = 0
else:
if np.abs(input) < 1e-10:
input = 0
return input
# -------------------------------------------------------------------------
# Reconstruction
# -------------------------------------------------------------------------
tiltSeries = scalars_array3d
tiltAngles = range(-sizeZ + 1, sizeZ, 2) # Delta angle of 2
(Nslice, Nray, Nproj) = tiltSeries.shape
Niter = 1
A = parallelRay(Nray, 1.0, tiltAngles, Nray, 1.0) # A is a sparse matrix
recon = np.empty([Nslice, Nray, Nray], dtype=float, order='F')
A = A.todense()
(Nrow, Ncol) = A.shape
rowInnerProduct = np.zeros(Nrow)
row = np.zeros(Ncol)
f = np.zeros(Ncol) # Placeholder for 2d image
beta = 1.0
# Calculate row inner product
for j in range(Nrow):
row[:] = A[j, ].copy()
rowInnerProduct[j] = np.dot(row, row)
for s in range(Nslice):
f[:] = 0
b = tiltSeries[s, :, :].transpose().flatten()
for i in range(Niter):
for j in range(Nrow):
row[:] = A[j, ].copy()
row_f_product = np.dot(row, f)
a = (b[j] - row_f_product) / rowInnerProduct[j]
f = f + row * a * beta
recon[s, :, :] = f.reshape((Nray, Nray))
(iSize, jSize, kSize) = recon.shape
t1 = time.time()
print('%d # Reconstruction %s | ' % (idx, str(t1 - t0)))
t0 = t1
# -------------------------------------------------------------------------
# Convert reconstruction array into VTK format
# -------------------------------------------------------------------------
arr = recon.ravel(order='A')
vtkarray = numpy_support.numpy_to_vtk(arr)
vtkarray.SetName('Scalars')
t1 = time.time()
print('%d # Reshape result %s | ' % (idx, str(t1 - t0)))
t0 = t1
# -------------------------------------------------------------------------
# Data access helper
# -------------------------------------------------------------------------
def createSlice():
size = sizeY * sizeY
array = np.arange(size, dtype=np.int32)
return array
def getSideSlice(offset, xSize):
size = sizeY * sizeY
slice = np.arange(size, dtype=np.int32)
for i in range(size):
slice[i] = vtkarray.GetTuple1(int(offset + (i * xSize)))
return slice
# -------------------------------------------------------------------------
# Add ghost points from neighbors
# -------------------------------------------------------------------------
from mpi4py import MPI
comm = MPI.COMM_WORLD
remoteLowerSlice = None
remoteUpperSlice = None
if idx + 1 < targetPartition:
# Share upper slice
remoteUpperSlice = createSlice()
localUpperSlice = getSideSlice(xSizes[idx] - 1, xSizes[idx])
comm.Sendrecv(localUpperSlice, (idx + 1), (2 * idx + 1),
remoteUpperSlice, (idx + 1), (2 * idx))
if idx > 0:
# Share lower slice
remoteLowerSlice = createSlice()
localLowerSlice = getSideSlice(0, xSizes[idx])
comm.Sendrecv(localLowerSlice, (idx - 1), (2 * (idx - 1)),
remoteLowerSlice, (idx - 1), (2 * (idx - 1) + 1))
t1 = time.time()
print('%d # MPI share %s | ' % (idx, str(t1 - t0)))
t0 = t1
# -------------------------------------------------------------------------
dataset = vtkImageData()
minX = 0
maxX = 0
for i in range(idx + 1):
minX = maxX
maxX += xSizes[i]
# -------------------------------------------------------------------------
# Add slice(s) to data
# -------------------------------------------------------------------------
arrayWithSlices = vtkarray.NewInstance()
arrayWithSlices.SetName('Scalars')
if remoteLowerSlice != None and remoteUpperSlice != None:
# Add both slices
minX -= 1
maxX += 1
localSizeX = maxX - minX
newSize = localSizeX * sizeY * sizeY
arrayWithSlices.SetNumberOfTuples(newSize)
localOffset = 0
for i in range(newSize):
if i % localSizeX == 0:
arrayWithSlices.SetTuple1(i, remoteLowerSlice[i / localSizeX])
elif (i + 1) % localSizeX == 0:
arrayWithSlices.SetTuple1(
i, remoteUpperSlice[((i + 1) / localSizeX) - 1])
else:
arrayWithSlices.SetTuple1(i, vtkarray.GetTuple1(localOffset))
localOffset += 1
elif remoteLowerSlice != None:
# Add lower slice
minX -= 1
localSizeX = maxX - minX
newSize = localSizeX * sizeY * sizeY
arrayWithSlices.SetNumberOfTuples(newSize)
localOffset = 0
for i in range(newSize):
if i % localSizeX == 0:
arrayWithSlices.SetTuple1(i, remoteLowerSlice[i / localSizeX])
else:
arrayWithSlices.SetTuple1(i, vtkarray.GetTuple1(localOffset))
localOffset += 1
elif remoteUpperSlice != None:
# Add upper slice
maxX += 1
localSizeX = maxX - minX
newSize = localSizeX * sizeY * sizeY
arrayWithSlices.SetNumberOfTuples(newSize)
localOffset = 0
for i in range(newSize):
if (i + 1) % localSizeX == 0:
arrayWithSlices.SetTuple1(
i, remoteUpperSlice[((i + 1) / localSizeX) - 1])
else:
arrayWithSlices.SetTuple1(i, vtkarray.GetTuple1(localOffset))
localOffset += 1
dataset.SetExtent(minX, maxX - 1, 0, sizeY - 1, 0, sizeY - 1)
dataset.GetPointData().SetScalars(arrayWithSlices)
t1 = time.time()
print('%d # build resutling image data %s | ' % (idx, str(t1 - t0)))
t0 = t1
# -------------------------------------------------------------------------
vtkDistributedTrivialProducer.SetGlobalOutput('Spark', dataset)
from vtk.vtkPVClientServerCoreCore import vtkProcessModule
from paraview import simple
from paraview.web import wamp as pv_wamp
from paraview.web import protocols as pv_protocols
from vtk.web import server
pm = vtkProcessModule.GetProcessModule()
class Options(object):
debug = False
nosignalhandlers = True
host = 'localhost'
port = 9753
timeout = 300
content = '/data/sebastien/SparkMPI/runtime/visualizer/dist'
forceFlush = False
sslKey = ''
sslCert = ''
ws = 'ws'
lp = 'lp'
hp = 'hp'
nows = False
nobws = False
nolp = False
fsEndpoints = ''
uploadPath = None
testScriptPath = ''
baselineImgDir = ''
useBrowser = 'nobrowser'
tmpDirectory = '.'
testImgFile = ''
class _VisualizerServer(pv_wamp.PVServerProtocol):
dataDir = '/data'
groupRegex = "[0-9]+\\.[0-9]+\\.|[0-9]+\\."
excludeRegex = "^\\.|~$|^\\$"
allReaders = True
viewportScale = 1.0
viewportMaxWidth = 2560
viewportMaxHeight = 1440
proxies = '/data/sebastien/SparkMPI/defaultProxies.json'
def initialize(self):
# Bring used components
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebFileListing(
_VisualizerServer.dataDir, "Home",
_VisualizerServer.excludeRegex,
_VisualizerServer.groupRegex))
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebProxyManager(
baseDir=_VisualizerServer.dataDir,
allowedProxiesFile=_VisualizerServer.proxies,
allowUnconfiguredReaders=_VisualizerServer.allReaders))
self.registerVtkWebProtocol(pv_protocols.ParaViewWebColorManager())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebMouseHandler())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebViewPort(
_VisualizerServer.viewportScale,
_VisualizerServer.viewportMaxWidth,
_VisualizerServer.viewportMaxHeight))
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebViewPortImageDelivery())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebViewPortGeometryDelivery())
self.registerVtkWebProtocol(pv_protocols.ParaViewWebTimeHandler())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebSelectionHandler())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebWidgetManager())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebKeyValuePairStore())
self.registerVtkWebProtocol(
pv_protocols.ParaViewWebSaveData(
baseSavePath=_VisualizerServer.dataDir))
# Disable interactor-based render calls
simple.GetRenderView().EnableRenderOnInteraction = 0
simple.GetRenderView().Background = [0, 0, 0]
# Update interaction mode
pxm = simple.servermanager.ProxyManager()
interactionProxy = pxm.GetProxy('settings',
'RenderViewInteractionSettings')
interactionProxy.Camera3DManipulators = [
'Rotate', 'Pan', 'Zoom', 'Pan', 'Roll', 'Pan', 'Zoom',
'Rotate', 'Zoom'
]
# -------------------------------------------------------------------------
print('%d # > Start visualization - %s | ' % (idx, str(datetime.now())))
# -------------------------------------------------------------------------
args = Options()
if pm.GetPartitionId() == 0:
producer = simple.DistributedTrivialProducer()
producer.UpdateDataset = ''
producer.UpdateDataset = 'Spark'
producer.WholeExtent = [0, sizeX - 1, 0, sizeY - 1, 0, sizeY - 1]
server.start_webserver(options=args, protocol=_VisualizerServer)
pm.GetGlobalController().TriggerBreakRMIs()
print('%d # < Stop visualization - %s | ' % (idx, str(datetime.now())))
yield (idx, targetPartition)
"default": "0",
"type": "range",
"values": self.time_steps,
"label": "time",
"priority": 0
}
}
# =============================================================================
# Main: Parse args and start server
# =============================================================================
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(
description="ParaView/Web Pipeline Manager web-application")
# Add arguments
server.add_arguments(parser)
_PVCatalystManager.add_arguments(parser)
# Exctract arguments
args = parser.parse_args()
# Configure our current application
_PVCatalystManager.configure(args)
# Start server
server.start_webserver(options=args, protocol=_PVCatalystManager)
self.Application.GetObjectIdMap().SetActiveObject(
"VIEW", view.GetRenderWindow())
# =============================================================================
# Main: Parse args and start server
# =============================================================================
if __name__ == "__main__":
# Create argument parser
parser = argparse.ArgumentParser(
description="VTK/Web Tree web-application")
# Add default arguments
server.add_arguments(parser)
# Add local arguments
parser.add_argument("--tree", help="path to phy tree file", dest="tree")
parser.add_argument("--table", help="path to csv file", dest="table")
# Exctract arguments
args = parser.parse_args()
# Configure our current application
_PhylogeneticTree.authKey = args.authKey
_PhylogeneticTree.treeFilePath = args.tree
_PhylogeneticTree.csvFilePath = args.table
# Start server
server.start_webserver(options=args, protocol=_PhylogeneticTree)
args.timeout = 10 args.content = '' args.nosignalhandlers = False args.authKey = 'vtkweb-secret' args.forceFlush = False args.testScriptPath = '' args.baselineImgDir = '' args.uploadPath = None args.path = '.' args.file = None args.dsHost = None args.dsPort = 11111 args.rsHost = None args.rsPort = 11111 args.rcPort = -1 args.plugins = "" args.exclude = "^\\.|~$|^\\$" args.group = "[0-9]+\\." args.palettes = None args.proxies = None args.no_auto_readers = False args.sslKey = None args.sslCert = None args.ws = 'ws' args.lp = 'lp' args.nows = False args.nolp = False args.nobws = False # Start server server.start_webserver(options=args, protocol=pv_web_visualizer._VisualizerServer)
uploadPath = '.'
def initialize(self):
# intialize protocols
self.registerVtkWebProtocol(protocols.MouseHandler())
self.registerVtkWebProtocol(protocols.ViewPort())
self.registerVtkWebProtocol(protocols.RemoteRender())
self.registerVtkWebProtocol(
protocols.FileBrowser(
self.uploadPath,
"Home"
)
)
self.registerVtkWebProtocol(protocols.FileLoader(self.uploadPath))
self.registerVtkWebProtocol(protocols.FileFinder(self.uploadPath))
self.registerVtkWebProtocol(protocols.ViewportDeleter())
self.registerVtkWebProtocol(CDatProtocol())
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description='CDATWeb visualization server'
)
server.add_arguments(parser)
args = parser.parse_args()
CDATWebVisualizer.uploadPath = args.uploadPath
print("CDATWeb Visualization server initializing")
server.start_webserver(options=args, protocol=CDATWebVisualizer)
pv_web_visualizer._PipelineManager.authKey = 'paraviewweb-secret'
pv_web_visualizer._PipelineManager.dataDir = '.'
# Setup static args
class TestArgs:
pass
args = TestArgs()
args.host = 'localhost'
args.port = 8081
args.debug = 1
args.timeout = 10
args.content = ''
args.nosignalhandlers = False
args.authKey = 'vtkweb-secret'
args.forceFlush = False
args.testScriptPath = ''
args.baselineImgDir = ''
args.path = '.'
args.file = None
args.dsHost = None
args.dsPort = 11111
args.rsHost = None
args.rsPort = 11111
# Start server
server.start_webserver(options=args,
protocol=pv_web_visualizer._PipelineManager)
def start():
args = WebArguments('%s/www' % build_path)
TestProtocol.updateArguments(args)
server.start_webserver(options=args, protocol=TestProtocol)
