def setupApplication(cls): """Setups the default application state.""" # read data directory. root = {"name": "ROOT", "dirs": [], "files": []} directory_map = {} directory_map[_DataProber.DataPath] = root for path, dirs, files in os.walk(_DataProber.DataPath): element = directory_map[path] for name in dirs: item = {"name": name, "dirs": [], "files": []} item["name"] = name directory_map[os.path.join(path, name)] = item element["dirs"].append(item) element["files"] = [] for name in files: relpath = os.path.relpath(os.path.join(path, name), _DataProber.DataPath) item = {"name": name, "itemValue": relpath} element["files"].append(item) cls.Database = root cls.View = simple.CreateRenderView() simple.Render() # setup animation scene scene = simple.GetAnimationScene() simple.GetTimeTrack() scene.PlayMode = "Snap To TimeSteps"
def __init__(self, x): #NOTE: 'x' is required in order to instantiate an actor across all nodes by passing #a sequence of variables import paraview paraview.options.batch = True paraview.options.symmetric = True import paraview.simple as pvs self.pvs = pvs from mpi4py import MPI self.rank, self.size = MPI.COMM_WORLD.Get_rank( ), MPI.COMM_WORLD.Get_size() import vtk from vtk import vtkWindowToImageFilter # Create render view and image transfer filter objects self.renv = pvs.CreateRenderView() self.w2i = vtkWindowToImageFilter() self.w2i.ReadFrontBufferOff() self.w2i.ShouldRerenderOff() self.w2i.SetInput(self.renv.SMProxy.GetRenderWindow()) # Make sure all ranks have initialized MPI.COMM_WORLD.Barrier() if self.rank == 0: print("All ranks ready for rendering")
def render(self): self.view = paraview.CreateRenderView() self.source = paraview.DICOMReaderdirectory( FileName=self.directory_path) self.display = paraview.Show(self.source, self.view) paraview.ResetCamera() camera = paraview.GetActiveCamera() self.view.CenterOfRotation = camera.GetFocalPoint() self.view.CameraParallelProjection = 1 self.view.Background = [0, 0, 0] self.current_slice = self.display.Slice self.display.Representation = self.representation self.display.ColorArrayName = self.array_name paraview.ColorBy(self.display, self.array_name) color_map = paraview.GetColorTransferFunction(self.array_name, self.display) opacity_map = paraview.GetOpacityTransferFunction( self.array_name, self.display) scale_min = color_map.RGBPoints[0] scale_max = color_map.RGBPoints[-4] scale_middle = (scale_max - scale_min) / 2 self.scale_range = (scale_min, scale_max) color_map.RGBPoints = [ scale_min, 0.0, 0.0, 0.0, scale_max, 1.0, 1.0, 1.0, ] opacity_map.Points = [ scale_min, 0.0, 0.5, 0.0, scale_middle, 0.5, 0.5, 0.0, scale_max, 1.0, 0.5, 0.0, ] paraview.Render(self.view)
def createSliceExporter(self): self.analysis.register_analysis( "slice", # id "Slice exploration", # title "Perform 10 slice along X", # description "{time}/{sliceColor}_{slicePosition}.jpg", # data structure cinema.SliceExplorer.get_data_type()) nb_slices = 5 colorByArray = { "velocity": { "lut": self.lut , "type": 'POINT_DATA'} } view = simple.CreateRenderView() fng = self.analysis.get_file_name_generator("slice") exporter = cinema.SliceExplorer(fng, view, input, colorByArray, nb_slices) exporter.set_analysis(self.analysis) self.exporters.append(exporter)
def updateContents(self, inputPorts): if self.view == None: self.view = pvsp.CreateRenderView() renWin = self.view.GetRenderWindow() self.SetRenderWindow(renWin) iren = renWin.GetInteractor() iren.SetNonInteractiveRenderDelay(0) iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera()) # Load the uvcdat logo and use it for overlay logoPath = ( system.vistrails_root_directory() + "/gui/uvcdat/resources/images/uvcdat_logo_transparent.png") reader = vtk.vtkPNGReader() reader.SetFileName(logoPath) reader.Update() imageActor = vtk.vtkImageActor() imageActor.SetInputData(reader.GetOutput()) self.overlayRenderer = vtk.vtkRenderer() self.overlayRenderer.AddActor(imageActor) renWin.SetNumberOfLayers(renWin.GetNumberOfLayers() + 1) self.overlayRenderer.SetLayer(renWin.GetNumberOfLayers() - 1) renWin.AddRenderer(self.overlayRenderer) self.overlayRenderer.SetViewport(0.7, 0, 1.0, 0.3) del self.view.Representations[:] # Fetch variables from the input port (location, representations) = inputPorts for rep in representations: rep.set_view(self.view) rep.execute() # Set view specific properties self.view.CenterAxesVisibility = 0 self.view.Background = [0.6, 0.6, 0.6] self.view.ResetCamera() self.view.StillRender() QCellWidget.updateContents(self, inputPorts)
def simple360(self): self.analysis.register_analysis( "360", # id "rotation", # title "Perform 15 contour", # description "{time}/{theta}_{phi}.jpg", # data structure cinema.ThreeSixtyImageStackExporter.get_data_type()) fng = self.analysis.get_file_name_generator("360") arrayName = ('POINT_DATA', 'velocity') view = simple.CreateRenderView() rep = simple.Show(input, view) rep.LookupTable = self.lut rep.ColorArrayName = arrayName exporter = cinema.ThreeSixtyImageStackExporter(fng, view, self.center_of_rotation, self.distance, self.rotation_axis, [20,45]) self.exporters.append(exporter)
def updateContents(self, inputPorts): if self.view == None: self.view = pvsp.CreateRenderView() renWin = self.view.GetRenderWindow() self.SetRenderWindow(renWin) iren = renWin.GetInteractor() print type(iren) iren.SetNonInteractiveRenderDelay(0) iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera()) (representations, ) = inputPorts self.view.Representations = [] for r in representations: self.view.Representations.append(r.pvInstance) self.view.ResetCamera() self.view.StillRender() QCellWidget.updateContents(self, inputPorts)
def runTest(): options = servermanager.vtkRemotingCoreConfiguration.GetInstance() url = options.GetServerURL() smp.Connect(getHost(url), getPort(url)) r = smp.CreateRenderView() r.RemoteRenderThreshold = 20 s = smp.Sphere() s.PhiResolution = 80 s.ThetaResolution = 80 d = smp.Show() d.Representation = "Wireframe" smp.Render() r.RemoteRenderThreshold = 0 smp.Render() s.PhiResolution = 8 s.ThetaResolution = 8 smp.Render() smtesting.ProcessCommandLineArguments() if not smtesting.DoRegressionTesting(r.SMProxy): raise smtesting.TestError ("Test failed!!!") print ("Test Passed")
def test_composite(self): pv.Connect() # get a new context like a normal script would print "\nTEST_COMPOSITE" # set up some processing task view_proxy = pv.CreateRenderView() view_proxy.OrientationAxesVisibility = 0 s = pv.Wavelet() contour = pv.Contour(Input=s, ContourBy='RTData', ComputeScalars=1) sliceRep = pv.Show(contour) # make or open a cinema data store to put results in fname = "/tmp/test_pv_composite/info.json" cs = file_store.FileStore(fname) cs.add_metadata({'type': 'composite-image-stack'}) cs.add_metadata({'store_type': 'FS'}) cs.add_metadata({'version': '0.1'}) cs.filename_pattern = "results.png" cs.add_parameter( "phi", store.make_parameter('phi', [90, 120, 140])) cs.add_parameter( "theta", store.make_parameter('theta', [-90, -30, 30, 90])) cs.add_layer( "vis", store.make_parameter("vis", ['contour'])) contours = [50, 100, 150, 200] cs.add_control("isoval", store.make_parameter('isoval', contours)) cs.assign_parameter_dependence("isoval", "vis", ['contour']) cs.add_field("color", store.make_field('color', {'white': 'rgb', 'depth': 'depth', 'lum': 'luminance', 'RTData_1': 'lut'},), "isoval", contours) # associate control points with parameters of the data store cam = pv_explorers.Camera([0, 0, 0], [0, 1, 0], 75.0, view_proxy) showcontour = pv_explorers.SourceProxyInLayer("contour", sliceRep, contour) layertrack = explorers.Layer("vis", [showcontour]) filt = pv_explorers.Contour("isoval", contour) # additional specification necessary for the color field colorChoice = pv_explorers.ColorList() colorChoice.AddSolidColor('white', [1, 1, 1]) colorChoice.AddLUT('POINTS', 'RTData_1', 'X') colorChoice.AddDepth('depth') colorChoice.AddLuminance('lum') col = pv_explorers.Color("color", colorChoice, sliceRep) paramNames = ["phi", "theta", "vis", "isoval", "color"] trackList = [cam, layertrack, filt, col] e = pv_explorers.ImageExplorer(cs, paramNames, trackList, view_proxy) # run through all parameter combinations and put data into the store e.explore() # Reproduce an entry and compare vs. loaded # First set the parameters to reproduce cam.execute(store.Document({'theta': 30, 'phi': 140})) filt.execute(store.Document({'isoval': 100})) col.execute(store.Document({'color': 'RTData_1'})) imageslice = ch.pvRenderToArray(view_proxy) # Now load the corresponding cs2 = file_store.FileStore(fname) cs2.load() docs = [] for doc in cs2.find({'theta': 30, 'phi': 140, 'isoval': 100, 'color': 'RTData_1'}): docs.append(doc.data) # compare the two l2error = ch.compare_l2(imageslice, docs[0]) ncc = ch.compare_ncc(imageslice, docs[0]) success = (l2error < 1.0) and (ncc > 0.99) if not success: print "\n l2-error = ", l2error, " ; ncc = ", ncc, "\n" self.assertTrue(success) pv.Disconnect() # using a dedicated server state for each test
(-4.50, 0.0, 0.0), (-4.0, 0.0, 0.0), (-3.5, 0.0, 0.0), (-3.0, 0.0, 0.0), (3.0, 0.0, 0.0), (3.5, 0.0, 0.0), (4.0, 0.0, 0.0), (4.5, 0.0, 0.0), (5.0, 0.0, 0.0), (5.5, 0.0, 0.0), (6.0, 0.0, 0.0), (6.5, 0.0, 0.0), (6.7, 0.0, 0.0), (6.9, 0.0, 0.0), (7.0, 0.0, 0.0)] flines = {} i_integral = {} dsp = {} fwd = {} bkwd = {} min_sphr = {} min_sphr_disp = {} contours = {} contsphere_b = {} contsphere_f = {} rvs = pv.CreateRenderView() rvs.InteractionMode = '2D' rvs.CameraPosition = [0, -5, 0] rvs.CameraFocalPoint = [0, 0, 0] rvs.CameraViewUp = [0, 0, 1] rvs.CameraParallelScale = 11 rvs.AxesGrid.Visibility = 1 rvs.AxesGrid.AxesToLabel = 5 rvs.AxesGrid.GridColor = [0.8, 0.8, 0.8] rvs.AxesGrid.ShowGrid = 1 rvs.AxesGrid.XLabelColor = [0.2, 0.2, 0.2] rvs.AxesGrid.XTitleColor = [0.2, 0.2, 0.2] rvs.AxesGrid.ZLabelColor = [0.2, 0.2, 0.2] rvs.AxesGrid.ZTitleColor = [0.2, 0.2, 0.2] rvs.OrientationAxesVisibility = 0 rvs.ViewSize = [1920, 1280]
def test_slice(self): pv.Connect() # using a dedicated server state for each test print "\nTEST_SLICE" # set up some processing task view_proxy = pv.CreateRenderView() view_proxy.OrientationAxesVisibility = 0 s = pv.Sphere() sliceFilt = pv.Slice( SliceType="Plane", Input=s, SliceOffsetValues=[0.0]) sliceFilt.SliceType.Normal = [0, 1, 0] sliceRep = pv.Show(sliceFilt) # make or open a cinema data store to put results in fname = "/tmp/test_pv_slice/info.json" cs = file_store.FileStore(fname) cs.add_metadata({'type': 'parametric-image-stack'}) cs.add_metadata({'store_type': 'FS'}) cs.add_metadata({'version': '0.0'}) cs.filename_pattern = "{phi}_{theta}_{offset}_{color}_slice.png" cs.add_parameter( "phi", store.make_parameter('phi', [90, 120, 140])) cs.add_parameter( "theta", store.make_parameter('theta', [-90, -30, 30, 90])) cs.add_parameter( "offset", store.make_parameter('offset', [-.4, -.2, 0, .2, .4])) cs.add_parameter( "color", store.make_parameter( 'color', ['yellow', 'cyan', "purple"], typechoice='list')) colorChoice = pv_explorers.ColorList() colorChoice.AddSolidColor('yellow', [1, 1, 0]) colorChoice.AddSolidColor('cyan', [0, 1, 1]) colorChoice.AddSolidColor('purple', [1, 0, 1]) # associate control points with parameters of the data store cam = pv_explorers.Camera([0, 0, 0], [0, 1, 0], 10.0, view_proxy) filt = pv_explorers.Slice("offset", sliceFilt) col = pv_explorers.Color("color", colorChoice, sliceRep) params = ["phi", "theta", "offset", "color"] e = pv_explorers.ImageExplorer( cs, params, [cam, filt, col], view_proxy) # run through all parameter combinations and put data into the store e.explore() # Reproduce an entry and compare vs. loaded # First set the parameters to reproduce cam.execute(store.Document({'theta': -30, 'phi': 120})) filt.execute(store.Document({'offset': -.4})) col.execute(store.Document({'color': 'cyan'})) imageslice = ch.pvRenderToArray(view_proxy) # Now load the corresponding entry cs2 = file_store.FileStore(fname) cs2.load() docs = [] for doc in cs2.find( {'theta': -30, 'phi': 120, 'offset': -.4, 'color': 'cyan'}): docs.append(doc.data) # print "gen entry: \n", # imageslice, "\n", # imageslice.shape,"\n", # "loaded: \n", # docs[0], "\n", # docs[0].shape # compare the two l2error = ch.compare_l2(imageslice, docs[0]) ncc = ch.compare_ncc(imageslice, docs[0]) self.assertTrue((l2error < 1.0) and (ncc > 0.99)) pv.Disconnect() # using a dedicated server state for each test
import pv_utils as utils import paraview.simple as pv rdaTec = 'data/rhoda.tec' rhcTec = 'data/rhohc.tec' rnpTec = 'data/rho_fld_np.tec' surfTec = 'data/rho_surf.tec' white = [1.0, 1.0, 1.0] red = [0.67, 0.0, 0.0] green = [0.0, 0.67, 0.0] gold = [1.0, 0.85, 0.0] black = [0.0, 0.0, 0.0] center = utils.GetCenter(tecFile=rdaTec) renderView = pv.CreateRenderView(ViewSize=[700, 500], Background=white) utils.ColorSurface(tecFile=rdaTec, opacity=0.5) utils.NewContour(tecFile=rdaTec, color=red, opacity=0.5) utils.NewContour(tecFile=rhcTec, color=green, opacity=0.5) utils.NewContour(tecFile=rnpTec, color=gold, opacity=1.0) utils.NewContour(tecFile=surfTec, color=black, opacity=0.5) utils.SetCameraFocus(tecFile=rdaTec) utils.SetOrientation(camPosDir=[-1.0, -0.5, 0.3]) pv.SaveScreenshot('contours2.png')
def createPipeline(self): self.renderView = pvsimple.CreateRenderView() pvsimple.Sphere() pvsimple.Show()
analysis = cinema.AnalysisManager(work_directory, "Cinema Test", "Test various cinema explorers.") analysis.begin() # === SliceExplorer =========================================================== analysis.register_analysis( "slice", # id "Slice exploration", # title "Perform 10 slice along X", # description "{sliceColor}_{slicePosition}.jpg", # data structure cinema.SliceExplorer.get_data_type()) nb_slices = 5 colorByArray = {"RTData": {"lut": lut, "type": 'POINT_DATA'}} view = simple.CreateRenderView() fng = analysis.get_file_name_generator("slice") exporter = cinema.SliceExplorer(fng, view, data_to_explore, colorByArray, nb_slices) exporter.set_analysis(analysis) # Explore exporter.UpdatePipeline() # === ContourExplorer + ThreeSixtyImageStackExporter ========================== analysis.register_analysis( "contour-360", # id "Contour", # title "Perform 15 contour", # description
# else: # print "LT: ", localTime, ": ", t96_K0_ds.field_lines[localTime].startLoc # # print "Drift Shell [B_mirror(K)] (T96 K1000)" # for localTime in t96_K1000_ds.field_lines: # print "B(K1000): ", t96_K1000_ds.field_lines[localTime].get_B_mirror_for_K(1000) # if t96_K1000_ds.field_lines[localTime] is None: # print "LT: ", localTime, ": NO LINE FOUND" # else: # print "LT: ", localTime, ": ", t96_K1000_ds.field_lines[localTime].startLoc # # # Create a paraview render view so we can see visual progress. # pv._DisableFirstRenderCameraReset() rvs = pv.CreateRenderView() rvs.InteractionMode = '2D' rvs.CameraPosition = [0, -5, 0] rvs.CameraFocalPoint = [0, 0, 0] rvs.CameraViewUp = [0, 0, 1] rvs.CameraParallelScale = 11 rvs.AxesGrid.Visibility = 1 rvs.AxesGrid.AxesToLabel = 5 rvs.AxesGrid.GridColor = [0.8, 0.8, 0.8] rvs.AxesGrid.ShowGrid = 1 rvs.AxesGrid.XLabelColor = [0.2, 0.2, 0.2] rvs.AxesGrid.XTitleColor = [0.2, 0.2, 0.2] rvs.AxesGrid.ZLabelColor = [0.2, 0.2, 0.2] rvs.AxesGrid.ZTitleColor = [0.2, 0.2, 0.2] rvs.AxesGrid.YLabelColor = [0.2, 0.2, 0.2] rvs.AxesGrid.YTitleColor = [0.2, 0.2, 0.2]
I = fline.get_i_integrals() # ################################################# # To active plotting, uncomment everything below # # ################################################# x, y = ih.dict_to_x_y(I) fig1 = pl.figure() pl.plot(x,y) pl.xlabel("$B_{mirror}$ (nT)") pl.ylabel("$I(B_{mirror})$") pl.title("Field Line Geometry Integral $I$ with respect to $B_{mirror}$ \n For Field line that passes through (-40, 0, 0)") fig1.savefig("IwrtBm.png") # Create a paraview render view so we can see visual progress. # pv._DisableFirstRenderCameraReset() rv128 = pv.CreateRenderView() rv128.InteractionMode = '2D' rv128.CameraPosition = [0, -30, 0] rv128.CameraViewUp = [0, 0, 1] rv128.CameraParallelScale = 10 rv128.ViewSize = [1280, 1024] dipoleDisplay = pv.GetDisplayProperties(dipole128, view=rv128) # pv.Hide(dipole128, view=rv128) # create a new 'Sphere' sphere1 = pv.Sphere() sphere1.Radius = 1.0 sphere1.ThetaResolution = 64 sphere1.PhiResolution = 64 pv.Show(sphere1, rv128)
def test_contour(self): pv.Connect() # using a dedicated server state for each test print "\nTEST_CONTOUR" # set up some processing task view_proxy = pv.CreateRenderView() view_proxy.OrientationAxesVisibility = 0 view_proxy.ViewSize = [1024, 768] s = pv.Wavelet() contour = pv.Contour(Input=s, ContourBy='RTData', ComputeScalars=1) sliceRep = pv.Show(contour) # make or open a cinema data store to put results in fname = "/tmp/test_pv_contour/info.json" cs = file_store.FileStore(fname) cs.add_metadata({'type': 'parametric-image-stack'}) cs.add_metadata({'store_type': 'FS'}) cs.add_metadata({'version': '0.0'}) cs.filename_pattern = "{phi}_{theta}_{contour}_{color}_contour.png" cs.add_parameter( "phi", store.make_parameter('phi', [90, 120, 140])) cs.add_parameter( "theta", store.make_parameter('theta', [-90, -30, 30, 90])) cs.add_parameter( "contour", store.make_parameter('contour', [50, 100, 150, 200])) cs.add_parameter( "color", store.make_parameter( 'color', ['white', 'RTData_1'], typechoice='list')) # associate control points with parameters of the data store cam = pv_explorers.Camera( [0, 0, 0], [0, 1, 0], 75.0, view_proxy) filt = pv_explorers.Contour("contour", contour) colorChoice = pv_explorers.ColorList() colorChoice.AddSolidColor('white', [1, 1, 1]) colorChoice.AddLUT('POINTS', 'RTData_1', 'X') col = pv_explorers.Color("color", colorChoice, sliceRep) params = ["phi", "theta", "contour", "color"] e = pv_explorers.ImageExplorer( cs, params, [cam, filt, col], view_proxy) # run through all parameter combinations and put data into the store e.explore() # Reproduce an entry and compare vs. loaded # First set the parameters to reproduce cam.execute(store.Document({'theta': 30, 'phi': 140})) filt.execute(store.Document({'contour': 100})) col.execute(store.Document({'color': 'RTData_1'})) imageslice = ch.pvRenderToArray(view_proxy) # Now load the corresponding cs2 = file_store.FileStore(fname) cs2.load() docs = [] for doc in cs2.find( {'theta': 30, 'phi': 140, 'contour': 100, 'color': 'RTData_1'}): docs.append(doc.data) # compare the two l2error = ch.compare_l2(imageslice, docs[0]) ncc = ch.compare_ncc(imageslice, docs[0]) success = (l2error < 1.0) and (ncc > 0.99) if not success: print "\n l2-error = ", l2error, " ; ncc = ", ncc, "\n" self.assertTrue(success) pv.Disconnect() # using a dedicated server state for each test
def render_frames( scene, frames_dir=None, frame_window=None, render_missing_frames=False, save_state_to_file=None, no_render=False, show_preview=False, show_progress=False, job_id=None, ): # Validate scene if scene["View"]["ViewSize"][0] % 16 != 0: logger.warning( "The view width should be a multiple of 16 to be compatible with" " QuickTime.") if scene["View"]["ViewSize"][1] % 2 != 0: logger.warning( "The view height should be even to be compatible with QuickTime.") render_start_time = time.time() # Setup layout layout = pv.CreateLayout("Layout") # Setup view if "Background" in scene["View"]: bg_config = scene["View"]["Background"] del scene["View"]["Background"] if isinstance(bg_config, list): if isinstance(bg_config[0], list): assert len(bg_config) == 2, ( "When 'Background' is a list of colors, it must have 2" " entries.") bg_config = dict( BackgroundColorMode="Gradient", Background=parse_as.color(bg_config[0]), Background2=parse_as.color(bg_config[1]), ) else: bg_config = dict( BackgroundColorMode="Single Color", Background=parse_as.color(bg_config), ) bg_config["UseColorPaletteForBackground"] = 0 scene["View"].update(bg_config) bg_config = None else: bg_config = None view = pv.CreateRenderView(**scene["View"]) pv.AssignViewToLayout(view=view, layout=layout, hint=0) # Set spherical background texture if bg_config is not None: bg_config["BackgroundColorMode"] = "Texture" skybox_datasource = bg_config["Datasource"] del bg_config["Datasource"] background_texture = pvserver.rendering.ImageTexture( FileName=parse_as.path(scene["Datasources"][skybox_datasource])) background_sphere = pv.Sphere(Radius=bg_config["Radius"], ThetaResolution=100, PhiResolution=100) background_texture_map = pv.TextureMaptoSphere(Input=background_sphere) pv.Show( background_texture_map, view, Texture=background_texture, BackfaceRepresentation="Cull Frontface", Ambient=1.0, ) # Load the waveform data file waveform_h5file, waveform_subfile = parse_as.file_and_subfile( scene["Datasources"]["Waveform"]) waveform_data = WaveformDataReader(FileName=waveform_h5file, Subfile=waveform_subfile) pv.UpdatePipeline() # Generate volume data from the waveform. Also sets the available time range. # TODO: Pull KeepEveryNthTimestep out of datasource waveform_to_volume_configs = scene["WaveformToVolume"] if isinstance(waveform_to_volume_configs, dict): waveform_to_volume_configs = [{ "Object": waveform_to_volume_configs, }] if "VolumeRepresentation" in scene: waveform_to_volume_configs[0]["VolumeRepresentation"] = scene[ "VolumeRepresentation"] waveform_to_volume_objects = [] for waveform_to_volume_config in waveform_to_volume_configs: volume_data = WaveformToVolume( WaveformData=waveform_data, SwshCacheDirectory=parse_as.path( scene["Datasources"]["SwshCache"]), **waveform_to_volume_config["Object"], ) if "Modes" in waveform_to_volume_config["Object"]: volume_data.Modes = waveform_to_volume_config["Object"]["Modes"] if "Polarizations" in waveform_to_volume_config["Object"]: volume_data.Polarizations = waveform_to_volume_config["Object"][ "Polarizations"] waveform_to_volume_objects.append(volume_data) # Compute timing and frames information time_range_in_M = ( volume_data.TimestepValues[0], volume_data.TimestepValues[-1], ) logger.debug(f"Full available data time range: {time_range_in_M} (in M)") if "FreezeTime" in scene["Animation"]: frozen_time = scene["Animation"]["FreezeTime"] logger.info(f"Freezing time at {frozen_time}.") view.ViewTime = frozen_time animation = None else: if "Crop" in scene["Animation"]: time_range_in_M = scene["Animation"]["Crop"] logger.debug(f"Cropping time range to {time_range_in_M} (in M).") animation_speed = scene["Animation"]["Speed"] frame_rate = scene["Animation"]["FrameRate"] num_frames = animate.num_frames( max_animation_length=time_range_in_M[1] - time_range_in_M[0], animation_speed=animation_speed, frame_rate=frame_rate, ) animation_length_in_seconds = num_frames / frame_rate animation_length_in_M = animation_length_in_seconds * animation_speed time_per_frame_in_M = animation_length_in_M / num_frames logger.info(f"Rendering {animation_length_in_seconds:.2f}s movie with" f" {num_frames} frames ({frame_rate} FPS or" f" {animation_speed:.2e} M/s or" f" {time_per_frame_in_M:.2e} M/frame)...") if frame_window is not None: animation_window_num_frames = frame_window[1] - frame_window[0] animation_window_time_range = ( time_range_in_M[0] + frame_window[0] * time_per_frame_in_M, time_range_in_M[0] + (frame_window[1] - 1) * time_per_frame_in_M, ) logger.info( f"Restricting rendering to {animation_window_num_frames} frames" f" (numbers {frame_window[0]} to {frame_window[1] - 1}).") else: animation_window_num_frames = num_frames animation_window_time_range = time_range_in_M frame_window = (0, num_frames) # Setup animation so that sources can retrieve the `UPDATE_TIME_STEP` animation = pv.GetAnimationScene() # animation.UpdateAnimationUsingDataTimeSteps() # Since the data can be evaluated at arbitrary times we define the time steps # here by setting the number of frames within the full range animation.PlayMode = "Sequence" animation.StartTime = animation_window_time_range[0] animation.EndTime = animation_window_time_range[1] animation.NumberOfFrames = animation_window_num_frames logger.debug( f"Animating from scene time {animation.StartTime} to" f" {animation.EndTime} in {animation.NumberOfFrames} frames.") def scene_time_from_real(real_time): return (real_time / animation_length_in_seconds * animation_length_in_M) # For some reason the keyframe time for animations is expected to be within # (0, 1) so we need to transform back and forth from this "normalized" time def scene_time_from_normalized(normalized_time): return animation.StartTime + normalized_time * ( animation.EndTime - animation.StartTime) def normalized_time_from_scene(scene_time): return (scene_time - animation.StartTime) / (animation.EndTime - animation.StartTime) # Setup progress measuring already here so volume data computing for # initial frame is measured if show_progress and not no_render: logging.getLogger().handlers = [TqdmLoggingHandler()] animation_window_frame_range = tqdm.trange( animation_window_num_frames, desc="Rendering", unit="frame", miniters=1, position=job_id, ) else: animation_window_frame_range = range(animation_window_num_frames) # Set the initial time step animation.GoToFirst() # Display the volume data. This will trigger computing the volume data at the # current time step. for volume_data, waveform_to_volume_config in zip( waveform_to_volume_objects, waveform_to_volume_configs): vol_repr = (waveform_to_volume_config["VolumeRepresentation"] if "VolumeRepresentation" in waveform_to_volume_config else {}) volume_color_by = config_color.extract_color_by(vol_repr) if (vol_repr["VolumeRenderingMode"] == "GPU Based" and len(volume_color_by) > 2): logger.warning( "The 'GPU Based' volume renderer doesn't support multiple" " components.") volume = pv.Show(volume_data, view, **vol_repr) pv.ColorBy(volume, value=volume_color_by) if "Slices" in scene: for slice_config in scene["Slices"]: slice_obj_config = slice_config.get("Object", {}) slice = pv.Slice(Input=volume_data) slice.SliceType = "Plane" slice.SliceOffsetValues = [0.0] slice.SliceType.Origin = slice_obj_config.get( "Origin", [0.0, 0.0, -0.3]) slice.SliceType.Normal = slice_obj_config.get( "Normal", [0.0, 0.0, 1.0]) slice_rep = pv.Show(slice, view, **slice_config.get("Representation", {})) pv.ColorBy(slice_rep, value=volume_color_by) # Display the time if "TimeAnnotation" in scene: time_annotation = pv.AnnotateTimeFilter(volume_data, **scene["TimeAnnotation"]) pv.Show(time_annotation, view, **scene["TimeAnnotationRepresentation"]) # Add spheres if "Spheres" in scene: for sphere_config in scene["Spheres"]: sphere = pv.Sphere(**sphere_config["Object"]) pv.Show(sphere, view, **sphere_config["Representation"]) # Add trajectories and objects that follow them if "Trajectories" in scene: for trajectory_config in scene["Trajectories"]: trajectory_name = trajectory_config["Name"] radial_scale = (trajectory_config["RadialScale"] if "RadialScale" in trajectory_config else 1.0) # Load the trajectory data traj_data_reader = TrajectoryDataReader( RadialScale=radial_scale, **scene["Datasources"]["Trajectories"][trajectory_name], ) # Make sure the data is loaded so we can retrieve timesteps. # TODO: This should be fixed in `TrajectoryDataReader` by # communicating time range info down the pipeline, but we had issues # with that (see also `WaveformDataReader`). traj_data_reader.UpdatePipeline() if "Objects" in trajectory_config: with animate.restore_animation_state(animation): follow_traj = FollowTrajectory( TrajectoryData=traj_data_reader) for traj_obj_config in trajectory_config["Objects"]: for traj_obj_key in traj_obj_config: if traj_obj_key in [ "Representation", "Visibility", "TimeShift", "Glyph", ]: continue traj_obj_type = getattr(pv, traj_obj_key) traj_obj_glyph = traj_obj_type( **traj_obj_config[traj_obj_key]) follow_traj.UpdatePipeline() traj_obj = pv.Glyph(Input=follow_traj, GlyphType=traj_obj_glyph) # Can't set this in the constructor for some reason traj_obj.ScaleFactor = 1.0 for glyph_property in (traj_obj_config["Glyph"] if "Glyph" in traj_obj_config else []): setattr( traj_obj, glyph_property, traj_obj_config["Glyph"][glyph_property], ) traj_obj.UpdatePipeline() if "TimeShift" in traj_obj_config: traj_obj = animate.apply_time_shift( traj_obj, traj_obj_config["TimeShift"]) pv.Show(traj_obj, view, **traj_obj_config["Representation"]) if "Visibility" in traj_obj_config: animate.apply_visibility( traj_obj, traj_obj_config["Visibility"], normalized_time_from_scene, scene_time_from_real, ) if "Tail" in trajectory_config: with animate.restore_animation_state(animation): traj_tail = TrajectoryTail(TrajectoryData=traj_data_reader) if "TimeShift" in trajectory_config: traj_tail = animate.apply_time_shift( traj_tail, trajectory_config["TimeShift"]) tail_config = trajectory_config["Tail"] traj_color_by = config_color.extract_color_by(tail_config) if "Visibility" in tail_config: tail_visibility_config = tail_config["Visibility"] del tail_config["Visibility"] else: tail_visibility_config = None tail_rep = pv.Show(traj_tail, view, **tail_config) pv.ColorBy(tail_rep, value=traj_color_by) if tail_visibility_config is not None: animate.apply_visibility( traj_tail, tail_visibility_config, normalized_time_from_scene=normalized_time_from_scene, scene_time_from_real=scene_time_from_real, ) if "Move" in trajectory_config: move_config = trajectory_config["Move"] logger.debug( f"Animating '{move_config['guiName']}' along trajectory.") with h5py.File(trajectory_file, "r") as traj_data_file: trajectory_data = np.array( traj_data_file[trajectory_subfile]) if radial_scale != 1.0: trajectory_data[:, 1:] *= radial_scale logger.debug(f"Trajectory data shape: {trajectory_data.shape}") animate.follow_path( gui_name=move_config["guiName"], trajectory_data=trajectory_data, num_keyframes=move_config["NumKeyframes"], scene_time_range=time_range_in_M, normalized_time_from_scene=normalized_time_from_scene, ) # Add non-spherical horizon shapes (instead of spherical objects following # trajectories) if "Horizons" in scene: for horizon_config in scene["Horizons"]: with animate.restore_animation_state(animation): horizon = pv.PVDReader(FileName=scene["Datasources"] ["Horizons"][horizon_config["Name"]]) if horizon_config.get("InterpolateTime", False): horizon = pv.TemporalInterpolator( Input=horizon, DiscreteTimeStepInterval=0) if "TimeShift" in horizon_config: horizon = animate.apply_time_shift(horizon, horizon_config["TimeShift"], animation) # Try to make horizon surfaces smooth. At low angular resoluton # they still show artifacts, so perhaps more can be done. horizon = pv.ExtractSurface(Input=horizon) horizon = pv.GenerateSurfaceNormals(Input=horizon) horizon_rep_config = horizon_config.get("Representation", {}) if "Representation" not in horizon_rep_config: horizon_rep_config["Representation"] = "Surface" if "AmbientColor" not in horizon_rep_config: horizon_rep_config["AmbientColor"] = [0.0, 0.0, 0.0] if "DiffuseColor" not in horizon_rep_config: horizon_rep_config["DiffuseColor"] = [0.0, 0.0, 0.0] if "Specular" not in horizon_rep_config: horizon_rep_config["Specular"] = 0.2 if "SpecularPower" not in horizon_rep_config: horizon_rep_config["SpecularPower"] = 10 if "SpecularColor" not in horizon_rep_config: horizon_rep_config["SpecularColor"] = [1.0, 1.0, 1.0] if "ColorBy" in horizon_rep_config: horizon_color_by = config_color.extract_color_by( horizon_rep_config) else: horizon_color_by = None horizon_rep = pv.Show(horizon, view, **horizon_rep_config) if horizon_color_by is not None: pv.ColorBy(horizon_rep, value=horizon_color_by) # Animate visibility if "Visibility" in horizon_config: animate.apply_visibility( horizon, horizon_config["Visibility"], normalized_time_from_scene=normalized_time_from_scene, scene_time_from_real=scene_time_from_real, ) if "Contours" in horizon_config: for contour_config in horizon_config["Contours"]: contour = pv.Contour(Input=horizon, **contour_config["Object"]) contour_rep = pv.Show(contour, view, **contour_config["Representation"]) pv.ColorBy(contour_rep, None) if "Visibility" in horizon_config: animate.apply_visibility( contour, horizon_config["Visibility"], normalized_time_from_scene= normalized_time_from_scene, scene_time_from_real=scene_time_from_real, ) # Configure transfer functions if "TransferFunctions" in scene: for tf_config in scene["TransferFunctions"]: colored_field = tf_config["Field"] transfer_fctn = pv.GetColorTransferFunction(colored_field) opacity_fctn = pv.GetOpacityTransferFunction(colored_field) tf.configure_transfer_function(transfer_fctn, opacity_fctn, tf_config["TransferFunction"]) # Save state file before configuring camera keyframes. # TODO: Make camera keyframes work with statefile if save_state_to_file is not None: pv.SaveState(save_state_to_file + ".pvsm") # Camera shots # TODO: Make this work with freezing time while the camera is swinging if animation is None: for i, shot in enumerate(scene["CameraShots"]): if (i == len(scene["CameraShots"]) - 1 or (shot["Time"] if "Time" in shot else 0.0) >= view.ViewTime): camera_motion.apply(shot) break else: camera_motion.apply_swings( scene["CameraShots"], scene_time_range=time_range_in_M, scene_time_from_real=scene_time_from_real, normalized_time_from_scene=normalized_time_from_scene, ) # Report time if animation is not None: report_time_cue = pv.PythonAnimationCue() report_time_cue.Script = """ def start_cue(self): pass def tick(self): import paraview.simple as pv import logging logger = logging.getLogger('Animation') scene_time = pv.GetActiveView().ViewTime logger.info(f"Scene time: {scene_time}") def end_cue(self): pass """ animation.Cues.append(report_time_cue) if show_preview and animation is not None: animation.PlayMode = "Real Time" animation.Duration = 10 animation.Play() animation.PlayMode = "Sequence" if no_render: logger.info("No rendering requested. Total time:" f" {time.time() - render_start_time:.2f}s") return if frames_dir is None: raise RuntimeError("Trying to render but `frames_dir` is not set.") if os.path.exists(frames_dir): logger.warning( f"Output directory '{frames_dir}' exists, files may be overwritten." ) else: os.makedirs(frames_dir) if animation is None: pv.Render() pv.SaveScreenshot(os.path.join(frames_dir, "frame.png")) else: # Iterate over frames manually to support filling in missing frames. # If `pv.SaveAnimation` would support that, here's how it could be # invoked: # pv.SaveAnimation( # os.path.join(frames_dir, 'frame.png'), # view, # animation, # FrameWindow=frame_window, # SuffixFormat='.%06d') # Note that `FrameWindow` appears to be buggy, so we set up the # `animation` according to the `frame_window` above so the frame files # are numberd correctly. for animation_window_frame_i in animation_window_frame_range: frame_i = frame_window[0] + animation_window_frame_i frame_file = os.path.join(frames_dir, f"frame.{frame_i:06d}.png") if render_missing_frames and os.path.exists(frame_file): continue logger.debug(f"Rendering frame {frame_i}...") animation.AnimationTime = ( animation.StartTime + time_per_frame_in_M * animation_window_frame_i) pv.Render() pv.SaveScreenshot(frame_file) logger.info(f"Rendered frame {frame_i}.") logger.info( f"Rendering done. Total time: {time.time() - render_start_time:.2f}s")
import pv_utils as utils import paraview.simple as pv center = utils.GetCenter(tecFile='data/rhoda.tec') renderView = pv.CreateRenderView(ViewSize=[700, 500], Background=[1.0, 1.0, 1.0]) utils.ColorSurface(tecFile='data/rhoda.tec', view=renderView, opacity=1.0) utils.SetCameraFocus(tecFile='data/rhoda.tec', view=renderView, camFoc=center) utils.SetOrientation(view=renderView, camPosDir=[-1.0, -0.5, 0.3]) pv.SaveScreenshot('surface.png', magnification=1, quality=100, view=renderView)
def __init__(self, filepath='.'): self.filepath = filepath self.time = 0.0 self.surfaceColorMode = 0 # Local range self.subSurfaceColorMode = 0 # Local range # Surface View self.viewSurface = simple.CreateRenderView(True) self.viewSurface.EnableRenderOnInteraction = 0 self.viewSurface.OrientationAxesVisibility = 0 self.viewSurface.Background = [0.9, 0.9, 0.9] self.viewSurface.InteractionMode = '2D' self.viewSurface.CameraParallelProjection = 1 # SubSurface view self.viewSubSurface = simple.CreateRenderView(True) self.viewSubSurface.EnableRenderOnInteraction = 0 self.viewSubSurface.OrientationAxesVisibility = 0 self.viewSubSurface.Background = [0.9, 0.9, 0.9] self.viewSubSurface.InteractionMode = '2D' self.viewSubSurface.CameraParallelProjection = 1 # Read dataset self.reader = simple.ParFlowReader(FileName=filepath, DeflectTerrain=1) self.readerSurface = simple.OutputPort(self.reader, 1) self.readerSubSurface = simple.OutputPort(self.reader, 0) # Water table depth self.waterTableDepth = simple.WaterTableDepth( Subsurface=self.readerSubSurface, Surface=self.readerSurface) self.cellCenter = simple.CellCenters(Input=self.waterTableDepth) self.wtdVectCalc = simple.Calculator(Input=self.cellCenter) self.wtdVectCalc.ResultArrayName = 'wtdVect' self.wtdVectCalc.Function = 'iHat + jHat + kHat * water table depth' self.waterTableDepthGlyph = simple.Glyph( Input=self.wtdVectCalc, GlyphType='Cylinder', ScaleFactor=500, GlyphMode='All Points', GlyphTransform='Transform2', ScaleArray=['POINTS', 'wtdVect'], VectorScaleMode='Scale by Components', ) self.waterTableDepthGlyph.GlyphTransform.Rotate = [90.0, 0.0, 0.0] self.waterTableDepthGlyph.GlyphType.Resolution = 12 self.waterTableDepthGlyph.GlyphType.Radius = 0.25 self.waterTableRepresentation = simple.Show(self.waterTableDepthGlyph, self.viewSubSurface) self.waterTableRepresentation.Visibility = 0 # Water balance self.waterBalance = simple.WaterBalance( Subsurface=self.readerSubSurface, Surface=self.readerSurface) self.waterBalanceOverTime = simple.PlotGlobalVariablesOverTime( Input=self.waterBalance) # Surface representation self.surfaceRepresentation = simple.Show(self.readerSurface, self.viewSurface) self.surfaceRepresentation.SetScalarBarVisibility( self.viewSurface, True) # SubSurface representation + slice extract self.reader.UpdatePipeline() self.voi = self.reader.GetClientSideObject().GetOutputDataObject( 0).GetExtent() self.extractSubset = simple.ExtractSubset(Input=self.readerSubSurface) self.subSurfaceRepresentation = simple.Show(self.extractSubset, self.viewSubSurface) self.subSurfaceRepresentation.Representation = 'Surface' # Reset camera + center of rotation simple.Render(self.viewSurface) simple.ResetCamera(self.viewSurface) self.viewSurface.CenterOfRotation = self.viewSurface.CameraFocalPoint simple.Render(self.viewSubSurface) simple.ResetCamera(self.viewSubSurface) self.viewSubSurface.CenterOfRotation = self.viewSubSurface.CameraFocalPoint # Time management self.animationScene = simple.GetAnimationScene() self.animationScene.UpdateAnimationUsingDataTimeSteps()