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)