def getLookupTableForArrayName(self, name, numSamples=255): lutProxy = simple.GetColorTransferFunction(name) lut = lutProxy.GetClientSideObject() dataRange = lut.GetRange() delta = (dataRange[1] - dataRange[0]) / float(numSamples) colorArray = vtkUnsignedCharArray() colorArray.SetNumberOfComponents(3) colorArray.SetNumberOfTuples(numSamples) rgb = [0, 0, 0] for i in range(numSamples): lut.GetColor(dataRange[0] + float(i) * delta, rgb) r = int(round(rgb[0] * 255)) g = int(round(rgb[1] * 255)) b = int(round(rgb[2] * 255)) colorArray.SetTuple3(i, r, g, b) # Add the color array to an image data imgData = vtkImageData() imgData.SetDimensions(numSamples, 1, 1) aIdx = imgData.GetPointData().SetScalars(colorArray) # Use the vtk data encoder to base-64 encode the image as png, using no compression encoder = vtkDataEncoder() # two calls in a row crash on Windows - bald timing hack to avoid the crash. time.sleep(0.01) b64Str = encoder.EncodeAsBase64Jpg(imgData, 100) return { "image": "data:image/jpg;base64," + b64Str, "range": dataRange, "name": name, }
def _apply_color_map(self, color_map): assert self._display is not None assert self._data is not None name = self._data.PointData.GetArray(0).Name # type: ignore self._display.ColorArrayName = ["POINTS", name] color_lut = ps.GetColorTransferFunction(name) color_lut.ApplyPreset(color_map, True)
def processFile(self): self._download_mesh_file() self.sideVisibility = [] self.sideNames = [] self.sideObjectValue = [] self.reader = simple.OpenDataFile(_MeshViewer.fileName) domain = self.reader.GetProperty('SideSetArrayStatus').GetDomain( 'array_list') sides = [] for i in range(domain.GetNumberOfStrings()): sideName = domain.GetString(i) self.sideVisibility.append(True) self.sideObjectValue.append(int(sideName.split(': ')[1])) self.sideNames.append(sideName) sides.append(sideName) self.reader.SideSetArrayStatus = sides self.reader.ElementBlocks = [] self.reader.UpdatePipeline() bounds = self.reader.GetDataInformation().GetBounds() box = simple.Box(XLength=(bounds[1] - bounds[0]), YLength=(bounds[3] - bounds[2]), ZLength=(bounds[5] - bounds[4]), Center=[ 0.5 * (bounds[0] + bounds[1]), 0.5 * (bounds[2] + bounds[3]), 0.5 * (bounds[4] + bounds[5]) ]) self.outline = simple.Show(box) self.outline.Representation = 'Outline' # Color/Annotation management annotations = [] self.colors = [] for i in range(domain.GetNumberOfStrings()): annotations.append(str(self.sideObjectValue[i])) annotations.append(self.sideNames[i]) self.colors.append(0.5) self.colors.append(0.5) self.colors.append(0.5) # Color management self.lut = simple.GetColorTransferFunction('ObjectId') self.lut.InterpretValuesAsCategories = 1 self.lut.Annotations = annotations self.lut.IndexedColors = self.colors mainRep = simple.Show(self.reader) vtkSMPVRepresentationProxy.SetScalarColoring(mainRep.SMProxy, 'ObjectId', vtkDataObject.CELL) self.view = simple.Render() self.view.Background = [0, 0, 0]
def processFile(self): self.sideVisibility = [] self.sideNames = [] self.sideObjectValue = [] self.blockVisibility = [] self.blockNames = [] self.blockObjectValue = [] self.reader = simple.OpenDataFile(_MeshViewer.fileName) # Get information about faces and blocks self.sideNames, self.sideValues = self.extractSubset( 'SideSetArrayStatus') self.blockNames, self.blockValues = self.extractSubset('ElementBlocks') # Show faces to start self.reader.SideSetArrayStatus = self.sideNames self.reader.ElementBlocks = [] self.reader.UpdatePipeline() # Set up initial visibilities self.sideVisibility = [True for i in xrange(len(self.sideNames))] self.blockVisibility = [True for i in xrange(len(self.blockNames))] self.showingFaces = True bounds = self.reader.GetDataInformation().GetBounds() box = simple.Box(XLength=(bounds[1] - bounds[0]), YLength=(bounds[3] - bounds[2]), ZLength=(bounds[5] - bounds[4]), Center=[ 0.5 * (bounds[0] + bounds[1]), 0.5 * (bounds[2] + bounds[3]), 0.5 * (bounds[4] + bounds[5]) ]) self.outline = simple.Show(box) self.outline.Representation = 'Outline' # Color/Annotation management self.faceAnnotations, self.faceColors = self.setupInitialColors( self.sideNames, self.sideValues) self.blockAnnotations, self.blockColors = self.setupInitialColors( self.blockNames, self.blockValues) # Color management, start with faces self.lut = simple.GetColorTransferFunction('ObjectId') self.lut.InterpretValuesAsCategories = 1 self.lut.Annotations = self.faceAnnotations self.lut.IndexedColors = self.faceColors mainRep = simple.Show(self.reader) vtkSMPVRepresentationProxy.SetScalarColoring(mainRep.SMProxy, 'ObjectId', vtkDataObject.CELL) self.view = simple.Render() self.view.Background = [0, 0, 0]
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)
class Pipeline: # Create data source "input" (provides simulation fields) simData = coprocessor.CreateProducer( datadescription, "input" ) # Write VTK output if requested if writeVtkOutput: fullWriter = pvs.XMLHierarchicalBoxDataWriter(Input=simData, DataMode="Appended", CompressorType="ZLib") # Set freq=1 to ensure that output is written whenever the pipeline runs coprocessor.RegisterWriter(fullWriter, filename='bg_out_%t.vth', freq=1) # Create a new render view to generate images renderView = pvs.CreateView('RenderView') renderView.ViewSize = [1500, 768] renderView.InteractionMode = '2D' renderView.AxesGrid = 'GridAxes3DActor' renderView.CenterOfRotation = [2.8, 1.7, 0.0] renderView.StereoType = 0 renderView.CameraPosition = [2.8, 1.7, 10000.0] renderView.CameraFocalPoint = [2.8, 1.7, 0.0] renderView.CameraParallelScale = 3.386 renderView.Background = [0.32, 0.34, 0.43] renderView.ViewTime = datadescription.GetTime() # Show simulation time with 1 digit after decimal point annotateTime = pvs.AnnotateTime() annotateTime.Format = 'time: %.1f' timeDisplay = pvs.Show(annotateTime, renderView) # Register the view with coprocessor and provide it with information such as # the filename to use. Set freq=1 to ensure that images are rendered whenever # the pipeline runs coprocessor.RegisterView(renderView, filename='bg_out_%t.png', freq=1, fittoscreen=1, magnification=1, width=1500, height=768, cinema={}) # Create colour transfer function for field LUT = pvs.GetColorTransferFunction(fieldName) LUT.RGBPoints = [9.355e-05, 0.231, 0.298, 0.753, 0.0674, 0.865, 0.865, 0.865, 0.135, 0.706, 0.0157, 0.149] LUT.ScalarRangeInitialized = 1.0 # Render data field and colour by field value using lookup table fieldDisplay = pvs.Show(simData, renderView) fieldDisplay.Representation = 'Surface' fieldDisplay.ColorArrayName = ['CELLS', fieldName] fieldDisplay.LookupTable = LUT
def __init__(self): self.center_of_rotation = [34.5, 32.45, 27.95] self.rotation_axis = [0.0, 0.0, 1.0] self.distance = 500.0 self.exporters = [] self.analysis = cinema.AnalysisManager( 'cinema', "Cinema", "Test various cinema exporter.") self.analysis.begin() min = 0.0 max = 642.0 self.lut = simple.GetColorTransferFunction( "velocity", RGBPoints=[min, 0.23, 0.299, 0.754, (min+max)*0.5, 0.865, 0.865, 0.865, max, 0.706, 0.016, 0.15]) # == self.createSliceExporter() self.createComposite() self.createImageResampler() self.simple360()
def show(self, key_array="x_velocity", source=None, rescale=False): """Show the rendered output on the screen.""" Input = source if source else self.nek5000 display = pv.Show(Input, self.renderView1) pv.ColorBy(display, ("POINTS", key_array)) if rescale: display.RescaleTransferFunctionToDataRange(True, False) display.SetScalarBarVisibility(source, True) # ... lot of parameters are possible here pv.SetActiveSource(source) try: LUT = pv.GetColorTransferFunction(key_array) PWF = pv.GetOpacityTransferFunction(key_array) except AttributeError: pass return display
def createColorTransferFunction(self, var, colors=None, nan_color=[1.,1.,1.], nan_opacity=None, auto_rescale_range_mode="Never"): """Create a color transfer function/color map """ # get color transfer function/color map fct = pv.GetColorTransferFunction(var) if auto_rescale_range_mode: fct.AutomaticRescaleRangeMode = auto_rescale_range_mode if colors: fct.RGBPoints = colors if nan_color: fct.NanColor = nan_color if nan_opacity is not None: fct.NanOpacity = nan_opacity fct.ScalarRangeInitialized = 1.0 return fct
def makeContour(self): # get color transfer function/color map for the data to color with. dataLUT = simple.GetColorTransferFunction(self.plotRecipe.get('EnumColorVariable')) # create a new 'Contour' contour = simple.Contour(Input=self.dataObject.getData()) #print "DoubleContourValue", self.plotRecipe.get('DoubleContourValue') #print "EnumContourVariable", self.plotRecipe.get('EnumContourVariable') # Properties modified on contour #contour.ContourBy = ['POINTS', self.plotRecipe.get('enum.contour.variable')] contour.ContourBy = ['POINTS', 'uds_0_scalar'] contour.Isosurfaces = self.plotRecipe.get('DoubleContourValue') # show data in view contourDisplay = simple.Show(contour, self.dataObject.renderView) # trace defaults for the display properties. contourDisplay.Representation = 'Surface' # show color bar/color legend contourDisplay.SetScalarBarVisibility(self.dataObject.renderView, True) # set scalar coloring ColorBy(contourDisplay, ('POINTS', self.plotRecipe.get('EnumColorVariable'), 'Magnitude')) # Hide the scalar bar for this color map if no visible data is # colored by it. simple.HideScalarBarIfNotNeeded(dataLUT, self.dataObject.renderView) # rescale color and/or opacity maps used to include current data range contourDisplay.RescaleTransferFunctionToDataRange(True, False) # reset view to fit data self.dataObject.renderView.ResetCamera() self.dataObject.renderView.Update()
def colorBy(self, representation, field): view = self.viewSubSurface if representation == self.subSurfaceRepresentation else self.viewSurface representation.SetScalarBarVisibility(view, False) simple.ColorBy(representation, ['CELLS', field]) applyColorMap(representation) representation.SetScalarBarVisibility(view, True) lut = simple.GetColorTransferFunction(field) colorBar = simple.GetScalarBar(lut, view) colorBar.Enabled = 1 colorBar.Selectable = 0 colorBar.AutoOrient = 0 colorBar.AutomaticLabelFormat = 1 colorBar.AddRangeLabels = 0 colorBar.ScalarBarLength = 0.9 colorBar.LabelColor = [0, 0, 0] colorBar.Position = [0.8, 0.05] colorBar.LockPosition = 1 colorBar.Repositionable = 1 colorBar.Resizable = 1 colorBar.TitleColor = [0, 0, 0]
class Pipeline: grid = coprocessor.CreateProducer(datadescription, 'input') # Simulation domain outline outline = pvs.Outline(Input=grid) # Horizontal slice at the bottom slice = pvs.Slice(Input=grid) slice.SliceType = 'Plane' slice.SliceOffsetValues = [0.0] slice.SliceType.Origin = [0.0, 0.0, 101.94] slice.SliceType.Normal = [0.0, 0.0, 1.0] slice.Triangulatetheslice = False # Glyphs for representing velocity field glyph = pvs.Glyph(Input=grid, GlyphType='Arrow') glyph.Vectors = ['CELLS', 'u'] glyph.ScaleMode = 'vector' glyph.ScaleFactor = 0.01 glyph.GlyphMode = 'Every Nth Point' glyph.Stride = 200 # Create a new render view renderView = pvs.CreateView('RenderView') renderView.ViewSize = [800, 400] renderView.InteractionMode = '2D' renderView.AxesGrid = 'GridAxes3DActor' renderView.CenterOfRotation = [0.18, 0.0, 102] renderView.StereoType = 0 renderView.CameraPosition = [-3.4, -6.8, 107] renderView.CameraFocalPoint = [-0.27, -0.41, 102] renderView.CameraViewUp = [0.057, 0.49, 0.87] renderView.CameraParallelScale = 1.0 renderView.Background = [0.32, 0.34, 0.43] # Register the view with coprocessor coprocessor.RegisterView(renderView, filename='image_%t.png', freq=1, fittoscreen=0, magnification=1, width=800, height=400, cinema={}) renderView.ViewTime = datadescription.GetTime() # Get color transfer function/color map for field rho rhoLUT = pvs.GetColorTransferFunction('rho') rhoLUT.RGBPoints = [ 1.17, 0.231, 0.298, 0.752, 1.33, 0.865, 0.865, 0.865, 1.49, 0.706, 0.0157, 0.149 ] rhoLUT.ScalarRangeInitialized = 1.0 # Show slice sliceDisplay = pvs.Show(slice, renderView) sliceDisplay.Representation = 'Surface With Edges' sliceDisplay.ColorArrayName = ['CELLS', 'rho'] sliceDisplay.LookupTable = rhoLUT sliceDisplay.ScaleFactor = 0.628 sliceDisplay.SelectScaleArray = 'None' sliceDisplay.GlyphType = 'Arrow' sliceDisplay.GlyphTableIndexArray = 'None' sliceDisplay.DataAxesGrid = 'GridAxesRepresentation' sliceDisplay.PolarAxes = 'PolarAxesRepresentation' sliceDisplay.GaussianRadius = 0.314 sliceDisplay.SetScaleArray = [None, ''] sliceDisplay.ScaleTransferFunction = 'PiecewiseFunction' sliceDisplay.OpacityArray = [None, ''] sliceDisplay.OpacityTransferFunction = 'PiecewiseFunction' # Show color legend sliceDisplay.SetScalarBarVisibility(renderView, True) # Show glyph glyphDisplay = pvs.Show(glyph, renderView) # Show outline outlineDisplay = pvs.Show(outline, renderView) # Get color legend/bar for rhoLUT in view renderView rhoLUTColorBar = pvs.GetScalarBar(rhoLUT, renderView) rhoLUTColorBar.WindowLocation = 'LowerRightCorner' rhoLUTColorBar.Title = 'rho' rhoLUTColorBar.ComponentTitle = ''
def applyPreset(self, arrayName, presetName): lutProxy = simple.GetColorTransferFunction(arrayName) lutProxy.ApplyPreset(presetName, True) self.getApplication().InvokeEvent("UpdateEvent")
def updateLookupTableRange(self, arrayName, dataRange): lutProxy = simple.GetColorTransferFunction(arrayName) vtkSMTransferFunctionProxy.RescaleTransferFunction( lutProxy.SMProxy, dataRange[0], dataRange[1], False) self.getApplication().InvokeEvent("UpdateEvent")
def main(): argparser = argparse.ArgumentParser() argparser.add_argument( '-d', '--data', required=True, help='Specify the directory containing the time series data') argparser.add_argument('-s', '--stats', help='The file name containing global statistics') argparser.add_argument( '-o', '--output', help= 'The name for the state file to be loaded by paraview, without an extension' ) options = argparser.parse_args() xdim, ydim = get_dims(options.data) virions_view = create_render_view('virions', xdim, ydim) virions_chart_view = create_chart_view('Average virions') epicells_view = create_render_view('epicells', xdim, ydim) epicells_chart_view = create_chart_view('epicells', log_scale=True, left_max_range=xdim * ydim) tcells_view = create_render_view('chemokines and tcells', xdim, ydim) tcells_chart_view = create_chart_view('tcells', log_scale=True, left_max_range=xdim * ydim) pvs.AddCameraLink(virions_view, epicells_view, 'link1') pvs.AddCameraLink(epicells_view, tcells_view, 'link2') virions_color_func = pvs.GetColorTransferFunction('virus') virions_color_func.RGBPoints = [ 0.0255, 0.231, 0.298, 0.753, 2.55, 0.865, 0.865, 0.865, 255.0, 0.706, 0.0157, 0.149 ] virions_color_func.UseLogScale = 0 display_data('sample_virus_', options.data, virions_view, 'virus', virions_color_func) display_chart(options.stats, virions_chart_view, ['virs'], ['virs', 'virions'], 'virions', ['virs', '1', '0', '0']) epicell_cols = [ 'incb', '1.0', '0.333', '1.0', 'expr', '0.667', '0.0', '0.0', 'apop', '1.0', '1.0', '0', 'dead', '0.333', '0.333', '0.0' ] epicell_cols_vals = [0.8, 0.8, 0.8] for i in range(len(epicell_cols)): if i % 4 == 0: continue epicell_cols_vals.append(float(epicell_cols[i])) epicells_color_func = pvs.GetColorTransferFunction('epicell') epicells_color_func.InterpretValuesAsCategories = 1 epicells_color_func.Annotations = [ '1', 'healthy', '2', 'incubating', '3', 'expressing', '4', 'apoptotic', '5', 'dead' ] epicells_color_func.IndexedColors = epicell_cols_vals display_data('sample_epicell_', options.data, epicells_view, 'epicell', epicells_color_func) display_chart(options.stats, epicells_chart_view, ['incb', 'expr', 'apop', 'dead'], [ 'incb', 'incubating', 'expr', 'expressing', 'apop', 'apoptotic', 'dead', 'dead' ], 'epicells', epicell_cols) chemokine_color_func = pvs.GetColorTransferFunction('chemokine') chemokine_color_func.RGBPoints = [ 0.0249, 0.0, 0.0, 0.0, 249.0, 1.0, 1.0, 1.0 ] chemokine_color_func.UseLogScale = 0 chemokine_color_func.NanOpacity = 0.0 display_data('sample_chemokine_', options.data, tcells_view, 'chemokine', chemokine_color_func) tcells_color_func = pvs.GetColorTransferFunction('t-cell-tissue') tcells_color_func.InterpretValuesAsCategories = 1 tcells_color_func.NanOpacity = 0.0 tcells_color_func.Annotations = [ '1', '>0', '2', '>0.12', '3', '>0.25', '4', '>0.5' ] tcells_color_func.IndexedColors = [ 0.0, 0.3, 0.0, 0.0, 0.5, 0.0, 0.0, 0.7, 0.0, 0.0, 1.0, 0.0 ] display_data('sample_tcelltissue_', options.data, tcells_view, 't-cell-tissue', tcells_color_func) #, representation='Points') display_chart(options.stats, tcells_chart_view, ['ttis', 'tvas'], ['ttis', 'tissue', 'tvas', 'vasculature'], 'tcells', ['ttis', '0', '1', '0', 'tvas', '0', '0', '1']) layout = pvs.CreateLayout(name='Main Layout') layout.SplitHorizontal(0, 0.333) layout.SplitVertical(1, 0.7) layout.SplitHorizontal(2, 0.5) layout.SplitVertical(5, 0.7) layout.SplitVertical(6, 0.7) layout.AssignView(3, virions_view) layout.AssignView(4, virions_chart_view) layout.AssignView(11, epicells_view) layout.AssignView(12, epicells_chart_view) layout.AssignView(13, tcells_view) layout.AssignView(14, tcells_chart_view) # for view in [virions_view, epicells_view, tcells_view]: # print(view.GetActiveCamera().GetViewUp()) # print(view.GetActiveCamera().GetPosition()) # print(view.GetActiveCamera().GetFocalPoint()) # for view in [virions_view, epicells_view, tcells_view]: # camera = view.GetActiveCamera() # focal_point = camera.GetFocalPoint() # pos = camera.GetPosition() # dist = math.sqrt((pos[0] - focal_point[0]) ** 2 + (pos[1] - focal_point[1]) ** 2 + (pos[2] - focal_point[2]) ** 2) # camera.SetPosition(focal_point[0], focal_point[1], focal_point[2] + dist) # camera.SetViewUp(0.0, 1.0, 0.0) if not options.output: state_fname = options.data + '-state.pvsm' else: state_fname = options.output + '.pvsm' pvs.servermanager.SaveState(state_fname) print('Created a state file', state_fname, 'for paraview') print('Run with\n', 'paraview', state_fname)
class Pipeline: # Read topographic data topo = pvs.XMLPolyDataReader(FileName="ETOPO_10min_Ice.vtp") # Scale data to just under radius of the sphere toposcaled = pvs.Calculator(Input=topo) toposcaled.CoordinateResults = 1 toposcaled.Function = '%i*coords' % (sphere_radius * 0.99) # Define source of pipeline grid = coprocessor.CreateProducer(datadescription, "input") ghosts = pvs.GhostCellsGenerator(Input=grid) ghosts.BuildIfRequired = 0 ghosts.MinimumNumberOfGhostLevels = 1 # Create a spherical slice slice = pvs.Slice(Input=ghosts) slice.SliceType = 'Sphere' slice.Triangulatetheslice = 0 slice.SliceOffsetValues = [0.0] slice.SliceType.Radius = sphere_radius # Convert cell data to point data, which is required for good contour results # # CAUTION: THIS FILTER AVERAGES DATA FROM ALL CELLS SURROUNDING A POINT, # WHICH REDUCES ACCURACY cell2point = pvs.CellDatatoPointData(Input=slice) cell2point.PassCellData = 0 cell2point.PieceInvariant = 0 # Create contours # Note that the "tube" filter can be used to highlight contours if needed. contours = pvs.Contour(Input=cell2point) contours.Isosurfaces = contour_values contours.ContourBy = ['POINTS', 'rho'] contours.PointMergeMethod = 'Uniform Binning' # Create a new render view renderView = pvs.CreateView('RenderView') renderView.ViewSize = [1500, 768] renderView.AxesGrid = 'GridAxes3DActor' renderView.StereoType = 0 renderView.CameraPosition = [0.0, 1.0, 0.3] renderView.CameraViewUp = [0.0, 0.0, 1.0] renderView.CameraParallelScale = 1.0 renderView.Background = [0.32, 0.34, 0.43] renderView.ViewTime = datadescription.GetTime() # Register the view with coprocessor # and provide it with information such as the filename to use, # how frequently to write the images, etc. coprocessor.RegisterView(renderView, filename='topo_contours_%t.png', freq=1, fittoscreen=1, magnification=1, width=800, height=800, cinema={}) # Create colour transfer function for field LUT = pvs.GetColorTransferFunction('altitude') # Use Wikipedia LUT as provided on http://www.earthmodels.org/data-and-tools/color-tables LUT.RGBPoints = [ -11000, 0.141176470588235, 0.149019607843137, 0.686274509803922, -5499.999, 0.219607843137255, 0.227450980392157, 0.764705882352941, -5500, 0.219607843137255, 0.227450980392157, 0.764705882352941, -2999.999, 0.274509803921569, 0.282352941176471, 0.83921568627451, -3000, 0.274509803921569, 0.282352941176471, 0.83921568627451, -1999.999, 0.317647058823529, 0.4, 0.850980392156863, -2000, 0.317647058823529, 0.4, 0.850980392156863, -749.999, 0.392156862745098, 0.505882352941176, 0.874509803921569, -750, 0.392156862745098, 0.505882352941176, 0.874509803921569, -69.999, 0.513725490196078, 0.631372549019608, 0.901960784313726, -70, 0.513725490196078, 0.631372549019608, 0.901960784313726, -19.999, 0.643137254901961, 0.752941176470588, 0.941176470588235, -20, 0.643137254901961, 0.752941176470588, 0.941176470588235, 0.001, 0.666666666666667, 0.784313725490196, 1, 0, 0, 0.380392156862745, 0.27843137254902, 50.001, 0.0627450980392157, 0.47843137254902, 0.184313725490196, 50, 0.0627450980392157, 0.47843137254902, 0.184313725490196, 500.001, 0.909803921568627, 0.843137254901961, 0.490196078431373, 500, 0.909803921568627, 0.843137254901961, 0.490196078431373, 1200.001, 0.631372549019608, 0.262745098039216, 0, 1200, 0.631372549019608, 0.262745098039216, 0, 1700.001, 0.509803921568627, 0.117647058823529, 0.117647058823529, 1700, 0.509803921568627, 0.117647058823529, 0.117647058823529, 2800.001, 0.431372549019608, 0.431372549019608, 0.431372549019608, 2800, 0.431372549019608, 0.431372549019608, 0.431372549019608, 4000.001, 1, 1, 1, 4000, 1, 1, 1, 6000.001, 1, 1, 1 ] LUT.ScalarRangeInitialized = 1.0 # Show topo data sphereDisplay = pvs.Show(toposcaled, renderView) sphereDisplay.Representation = 'Surface' sphereDisplay.ColorArrayName = ['POINTS', 'altitude'] sphereDisplay.LookupTable = LUT sphereDisplay.Opacity = 1.0 # Show surface and colour by field value (which is cell data) using lookup table sphereDisplay = pvs.Show(contours, renderView) sphereDisplay.Representation = 'Surface' sphereDisplay.Opacity = 1.0
materialLibrary1 = pv.GetMaterialLibrary() # update the view to ensure updated data information renderView1.Update() # set scalar coloring pv.ColorBy(ablnek5000Display, ('POINTS', 'x_velocity')) # rescale color and/or opacity maps used to include current data range ablnek5000Display.RescaleTransferFunctionToDataRange(True, False) # show color bar/color legend ablnek5000Display.SetScalarBarVisibility(renderView1, True) # get color transfer function/color map for 'x_velocity' x_velocityLUT = pv.GetColorTransferFunction('x_velocity') # get opacity transfer function/opacity map for 'x_velocity' x_velocityPWF = pv.GetOpacityTransferFunction('x_velocity') # set scalar coloring pv.ColorBy(ablnek5000Display, ('POINTS', 'y_velocity')) # Hide the scalar bar for this color map if no visible data is colored by it. pv.HideScalarBarIfNotNeeded(x_velocityLUT, renderView1) # rescale color and/or opacity maps used to include current data range ablnek5000Display.RescaleTransferFunctionToDataRange(True, False) # show color bar/color legend ablnek5000Display.SetScalarBarVisibility(renderView1, True)
def initialize(self): # Bring used components self.registerVtkWebProtocol(pv_protocols.ParaViewWebMouseHandler()) self.registerVtkWebProtocol(pv_protocols.ParaViewWebViewPort()) self.registerVtkWebProtocol( pv_protocols.ParaViewWebViewPortImageDelivery()) self.registerVtkWebProtocol(amsProtocol()) self.updateSecret(_DemoServer.authKey) # Disable interactor-based render calls simple.GetRenderView().EnableRenderOnInteraction = 0 simple.GetRenderView().Background = [0, 0, 0] #cone = simple.Cone() #simple.Show(cone) # create a new 'EnSight Reader' #### disable automatic camera reset on 'Show' #paraview.simple._DisableFirstRenderCameraReset() # create a new 'EnSight Reader' matvizmofTFF90L91lpm100rpmcase = simple.EnSightReader( CaseFileName= '/Users/tomfool/tech/18/amgen/ams-102-AgileViz/EnSight/mat-viz-mofTFF-90L-9.1lpm-100rpm/mat-viz-mofTFF-90L-9.1lpm-100rpm.case' ) matvizmofTFF90L91lpm100rpmcase.PointArrays = [ 'pressure', 'pressure_coefficient', 'dynamic_pressure', 'absolute_pressure', 'total_pressure', 'rel_total_pressure', 'density', 'density_all', 'velocity_magnitude', 'x_velocity', 'y_velocity', 'z_velocity', 'axial_velocity', 'radial_velocity', 'tangential_velocity', 'rel_velocity_magnitude', 'relative_x_velocity', 'relative_y_velocity', 'relative_z_velocity', 'rel_tangential_velocity', 'mesh_x_velocity', 'mesh_y_velocity', 'mesh_z_velocity', 'velocity_angle', 'relative_velocity_angle', 'vorticity_mag', 'helicity', 'x_vorticity', 'y_vorticity', 'z_vorticity', 'cell_reynolds_number', 'turb_kinetic_energy', 'turb_intensity', 'turb_diss_rate', 'production_of_k', 'viscosity_turb', 'viscosity_eff', 'viscosity_ratio', 'y_star', 'y_plus', 'uds_0_scalar', 'uds_0_diff_scalar', 'viscosity_lam', 'wall_shear', 'x_wall_shear', 'y_wall_shear', 'z_wall_shear', 'skin_friction_coef', 'cell_partition_active', 'cell_partition_stored', 'cell_id', 'cell_element_type', 'cell_type', 'cell_zone', 'partition_neighbors', 'cell_weight', 'x_coordinate', 'y_coordinate', 'z_coordinate', 'axial_coordinate', 'angular_coordinate', 'abs_angular_coordinate', 'radial_coordinate', 'face_area_magnitude', 'x_face_area', 'y_face_area', 'z_face_area', 'cell_volume', 'orthogonal_quality', 'cell_equiangle_skew', 'cell_equivolume_skew', 'face_handedness', 'mark_poor_elememts', 'interface_overlap_fraction', 'cell_wall_distance', 'adaption_function', 'adaption_curvature', 'adaption_space_gradient', 'adaption_iso_value', 'boundary_cell_dist', 'boundary_normal_dist', 'cell_volume_change', 'cell_surface_area', 'cell_warp', 'cell_children', 'cell_refine_level', 'mass_imbalance', 'strain_rate_mag', 'dx_velocity_dx', 'dy_velocity_dx', 'dz_velocity_dx', 'dx_velocity_dy', 'dy_velocity_dy', 'dz_velocity_dy', 'dx_velocity_dz', 'dy_velocity_dz', 'dz_velocity_dz', 'dp_dx', 'dp_dy', 'dp_dz', 'velocity' ] # get active view renderView1 = simple.GetActiveViewOrCreate('RenderView') # uncomment following to set a specific view size # renderView1.ViewSize = [1638, 1076] # show data in view matvizmofTFF90L91lpm100rpmcaseDisplay = simple.Show( matvizmofTFF90L91lpm100rpmcase, renderView1) # get color transfer function/color map for 'pressure' pressureLUT = simple.GetColorTransferFunction('pressure') # get opacity transfer function/opacity map for 'pressure' pressurePWF = simple.GetOpacityTransferFunction('pressure') # trace defaults for the display properties. matvizmofTFF90L91lpm100rpmcaseDisplay.Representation = 'Surface' matvizmofTFF90L91lpm100rpmcaseDisplay.ColorArrayName = [ 'POINTS', 'pressure' ] matvizmofTFF90L91lpm100rpmcaseDisplay.LookupTable = pressureLUT matvizmofTFF90L91lpm100rpmcaseDisplay.OSPRayScaleArray = 'pressure' matvizmofTFF90L91lpm100rpmcaseDisplay.OSPRayScaleFunction = 'PiecewiseFunction' matvizmofTFF90L91lpm100rpmcaseDisplay.SelectOrientationVectors = 'velocity' matvizmofTFF90L91lpm100rpmcaseDisplay.ScaleFactor = 0.07445502169430256 matvizmofTFF90L91lpm100rpmcaseDisplay.SelectScaleArray = 'pressure' matvizmofTFF90L91lpm100rpmcaseDisplay.GlyphType = 'Arrow' matvizmofTFF90L91lpm100rpmcaseDisplay.GlyphTableIndexArray = 'pressure' matvizmofTFF90L91lpm100rpmcaseDisplay.GaussianRadius = 0.03722751084715128 matvizmofTFF90L91lpm100rpmcaseDisplay.SetScaleArray = [ 'POINTS', 'pressure' ] matvizmofTFF90L91lpm100rpmcaseDisplay.ScaleTransferFunction = 'PiecewiseFunction' matvizmofTFF90L91lpm100rpmcaseDisplay.OpacityArray = [ 'POINTS', 'pressure' ] matvizmofTFF90L91lpm100rpmcaseDisplay.OpacityTransferFunction = 'PiecewiseFunction' matvizmofTFF90L91lpm100rpmcaseDisplay.DataAxesGrid = 'GridAxesRepresentation' matvizmofTFF90L91lpm100rpmcaseDisplay.SelectionCellLabelFontFile = '' matvizmofTFF90L91lpm100rpmcaseDisplay.SelectionPointLabelFontFile = '' matvizmofTFF90L91lpm100rpmcaseDisplay.PolarAxes = 'PolarAxesRepresentation' matvizmofTFF90L91lpm100rpmcaseDisplay.ScalarOpacityFunction = pressurePWF matvizmofTFF90L91lpm100rpmcaseDisplay.ScalarOpacityUnitDistance = 0.007476863260594431 # init the 'PiecewiseFunction' selected for 'ScaleTransferFunction' matvizmofTFF90L91lpm100rpmcaseDisplay.ScaleTransferFunction.Points = [ -152.6022491455078, 0.0, 0.5, 0.0, 144.73870849609375, 1.0, 0.5, 0.0 ] # init the 'PiecewiseFunction' selected for 'OpacityTransferFunction' matvizmofTFF90L91lpm100rpmcaseDisplay.OpacityTransferFunction.Points = [ -152.6022491455078, 0.0, 0.5, 0.0, 144.73870849609375, 1.0, 0.5, 0.0 ] # init the 'GridAxesRepresentation' selected for 'DataAxesGrid' matvizmofTFF90L91lpm100rpmcaseDisplay.DataAxesGrid.XTitleFontFile = '' matvizmofTFF90L91lpm100rpmcaseDisplay.DataAxesGrid.YTitleFontFile = '' matvizmofTFF90L91lpm100rpmcaseDisplay.DataAxesGrid.ZTitleFontFile = '' matvizmofTFF90L91lpm100rpmcaseDisplay.DataAxesGrid.XLabelFontFile = '' matvizmofTFF90L91lpm100rpmcaseDisplay.DataAxesGrid.YLabelFontFile = '' matvizmofTFF90L91lpm100rpmcaseDisplay.DataAxesGrid.ZLabelFontFile = '' # init the 'PolarAxesRepresentation' selected for 'PolarAxes' matvizmofTFF90L91lpm100rpmcaseDisplay.PolarAxes.PolarAxisTitleFontFile = '' matvizmofTFF90L91lpm100rpmcaseDisplay.PolarAxes.PolarAxisLabelFontFile = '' matvizmofTFF90L91lpm100rpmcaseDisplay.PolarAxes.LastRadialAxisTextFontFile = '' matvizmofTFF90L91lpm100rpmcaseDisplay.PolarAxes.SecondaryRadialAxesTextFontFile = '' # reset view to fit data renderView1.ResetCamera() # show color bar/color legend matvizmofTFF90L91lpm100rpmcaseDisplay.SetScalarBarVisibility( renderView1, True) # update the view to ensure updated data information renderView1.Update() # hide data in view simple.Hide(matvizmofTFF90L91lpm100rpmcase, renderView1) # create a new 'Contour' contour1 = simple.Contour(Input=matvizmofTFF90L91lpm100rpmcase) contour1.ContourBy = ['POINTS', 'pressure'] contour1.Isosurfaces = [-3.9317703247070312] contour1.PointMergeMethod = 'Uniform Binning' # Properties modified on contour1 contour1.ContourBy = ['POINTS', 'uds_0_scalar'] contour1.Isosurfaces = [480.0, 570.0] # show data in view contour1Display = simple.Show(contour1, renderView1) # trace defaults for the display properties. contour1Display.Representation = 'Surface' contour1Display.ColorArrayName = ['POINTS', 'pressure'] contour1Display.LookupTable = pressureLUT contour1Display.OSPRayScaleArray = 'Normals' contour1Display.OSPRayScaleFunction = 'PiecewiseFunction' contour1Display.SelectOrientationVectors = 'velocity' contour1Display.ScaleFactor = 0.07228952534496784 contour1Display.SelectScaleArray = 'None' contour1Display.GlyphType = 'Arrow' contour1Display.GlyphTableIndexArray = 'None' contour1Display.GaussianRadius = 0.03614476267248392 contour1Display.SetScaleArray = ['POINTS', 'Normals'] contour1Display.ScaleTransferFunction = 'PiecewiseFunction' contour1Display.OpacityArray = ['POINTS', 'Normals'] contour1Display.OpacityTransferFunction = 'PiecewiseFunction' contour1Display.DataAxesGrid = 'GridAxesRepresentation' contour1Display.SelectionCellLabelFontFile = '' contour1Display.SelectionPointLabelFontFile = '' contour1Display.PolarAxes = 'PolarAxesRepresentation' # init the 'PiecewiseFunction' selected for 'ScaleTransferFunction' contour1Display.ScaleTransferFunction.Points = [ -0.9995924830436707, 0.0, 0.5, 0.0, 0.9998393058776855, 1.0, 0.5, 0.0 ] # init the 'PiecewiseFunction' selected for 'OpacityTransferFunction' contour1Display.OpacityTransferFunction.Points = [ -0.9995924830436707, 0.0, 0.5, 0.0, 0.9998393058776855, 1.0, 0.5, 0.0 ] # init the 'GridAxesRepresentation' selected for 'DataAxesGrid' contour1Display.DataAxesGrid.XTitleFontFile = '' contour1Display.DataAxesGrid.YTitleFontFile = '' contour1Display.DataAxesGrid.ZTitleFontFile = '' contour1Display.DataAxesGrid.XLabelFontFile = '' contour1Display.DataAxesGrid.YLabelFontFile = '' contour1Display.DataAxesGrid.ZLabelFontFile = '' # init the 'PolarAxesRepresentation' selected for 'PolarAxes' contour1Display.PolarAxes.PolarAxisTitleFontFile = '' contour1Display.PolarAxes.PolarAxisLabelFontFile = '' contour1Display.PolarAxes.LastRadialAxisTextFontFile = '' contour1Display.PolarAxes.SecondaryRadialAxesTextFontFile = '' # reset view to fit data renderView1.ResetCamera() # hide data in view simple.Hide(matvizmofTFF90L91lpm100rpmcase, renderView1) # show color bar/color legend contour1Display.SetScalarBarVisibility(renderView1, True) # update the view to ensure updated data information renderView1.Update() # set scalar coloring simple.ColorBy(contour1Display, ('POINTS', 'velocity_magnitude')) # rescale color and/or opacity maps used to include current data range contour1Display.RescaleTransferFunctionToDataRange(True, False) # show color bar/color legend contour1Display.SetScalarBarVisibility(renderView1, True) # get color transfer function/color map for 'velocity_magnitude' velocity_magnitudeLUT = simple.GetColorTransferFunction( 'velocity_magnitude') #### saving camera placements for all active views # current camera placement for renderView1 renderView1.CameraPosition = [ 1.3051878628081257, -1.32358496378265, -0.017141331493847792 ] renderView1.CameraFocalPoint = [ -0.052487090229988105, 0.03264869749546056, -0.3026974257081747 ] renderView1.CameraViewUp = [ -0.5051031518286454, -0.33848038039346323, 0.7939155106820026 ] renderView1.CameraParallelScale = 0.5021485229089222 #### uncomment the following to render all views # RenderAllViews() # alternatively, if you want to write images, you can use SaveScreenshot(...). ### OLD FOLLOWS simple.Render() # Update interaction mode pxm = simple.servermanager.ProxyManager() interactionProxy = pxm.GetProxy('settings', 'RenderViewInteractionSettings') print(dir(interactionProxy)) interactionProxy.Camera3DManipulators = [ 'Rotate', 'Pan', 'Zoom', 'Pan', 'Roll', 'Pan', 'Zoom', 'Rotate', 'Zoom' ] print("done with initialize()")
class Pipeline: # Define source of pipeline grid = coprocessor.CreateProducer(datadescription, "input") if (write_full_output == True): fullWriter = pvs.XMLPUnstructuredGridWriter( Input=grid, DataMode="Appended", CompressorType="ZLib") coprocessor.RegisterWriter(fullWriter, filename='full_output_%t.pvtu', freq=1) # Horizontal slice at the bottom slice = pvs.Slice(Input=grid) slice.SliceType = 'Plane' slice.SliceOffsetValues = [0.0] slice.SliceType.Origin = [0.0, 0.0, 101.94] slice.SliceType.Normal = [0.0, 0.0, 1.0] slice.Triangulatetheslice = False # Set up spherical projection filter - we need to bridge into the # VTK universe and use a VTK transform filter; the ParaView transform filter # does not support geo transforms # Source projection - simulation data is provided in lon lat rad coordinates latlonproj = vtk.vtkGeoProjection() latlonproj.SetName('lonlat') latlonproj.SetCentralMeridian(0) # Target projection - use Mollweide here targetproj = vtk.vtkGeoProjection() targetproj.SetName('moll') targetproj.SetCentralMeridian(0) # Set up vtkGeoTransform object that defines the transformation transform = vtk.vtkGeoTransform() transform.SetSourceProjection(latlonproj) transform.SetDestinationProjection(targetproj) # Set up VTK transform filter object tffilter = vtk.vtkTransformFilter() tffilter.SetTransform(transform) tffilter.SetInputConnection( slice.GetClientSideObject().GetOutputPort(0)) # Return to ParaView universe by using a simple PassThrough filter to receive # output of the VTK transform filter passthrough = pvs.PassThrough() passthrough.GetClientSideObject().SetInputConnection( tffilter.GetOutputPort()) # Create a new render view renderView = pvs.CreateView('RenderView') renderView.ViewSize = [1500, 768] renderView.AxesGrid = 'GridAxes3DActor' renderView.StereoType = 0 renderView.CameraPosition = [0, 0, 4] renderView.CameraParallelScale = 1.7 renderView.Background = [0.32, 0.34, 0.43] renderView.ViewTime = datadescription.GetTime() # Register the view with coprocessor # and provide it with information such as the filename to use, # how frequently to write the images, etc. coprocessor.RegisterView(renderView, filename='spherical_slice_%t.png', freq=1, fittoscreen=1, magnification=1, width=1500, height=768, cinema={}) # Create colour transfer function for field LUT = pvs.GetColorTransferFunction(fieldname) LUT.RGBPoints = [ dataRange[0], 0.23, 0.30, 0.75, 0.5 * sum(dataRange), 0.87, 0.87, 0.87, dataRange[1], 0.71, 0.016, 0.15 ] LUT.ScalarRangeInitialized = 1.0 # Show surface and colour by field value (which is cell data) using lookup table sphereDisplay = pvs.Show(passthrough, renderView) sphereDisplay.Representation = 'Surface' sphereDisplay.ColorArrayName = ['CELLS', fieldname] sphereDisplay.LookupTable = LUT
data.UseCartesiancoordinates = 1 # Add a clip filter to the pipeline and set plane orientation clip = pvs.Clip(Input=data) clip.ClipType = 'Plane' clip.ClipType.Normal = [0.0, 0.0, 1.0] # Set up a new render view for displaying the grid and data renderView = pvs.CreateView('RenderView') renderView.ViewSize = [1600, 800] renderView.CameraPosition = [-43.0, 39.0, 32.0] renderView.CameraViewUp = [0.76, 0.44, 0.49] # Define a colour look-up table using (data value, r, g, b) tuples # Use value range from first timestep lut = pvs.GetColorTransferFunction('pressure') valueRange = data.CellData['pressure'].GetRange() lut.RGBPoints = [ valueRange[0], 0.23, 0.30, 0.75, valueRange[1], 0.71, 0.02, 0.15 ] # Show clip filter in the render view, render grid surfaces, # and colour surfaces using the pressure field and our LUT clipDisplay = pvs.Show(clip, renderView) clipDisplay.Representation = 'Surface With Edges' clipDisplay.ColorArrayName = ['CELLS', 'pressure'] clipDisplay.LookupTable = lut # Loop over time steps and render an image for each one timeSteps = data.TimestepValues for istep in range(0, len(timeSteps)):
renderView1.OrientationAxesLabelColor = [0.313, 0.313, 0.313] renderView1.StereoType = 0 renderView1.LightSwitch = 1 renderView1.LightIntensity = 0.2 renderView1.CameraParallelScale = 6520917.036707207 renderView1.Background = [1.0, 1.0, 1.0] kerner_kernelxdmf = simple.XDMFReader(FileNames=['kerner_kernel.xdmf']) kerner_kernelxdmf.GridStatus = ['grid'] kerner_all = simple.servermanager.Fetch(kerner_kernelxdmf) # Apparently, it is possible to use any name here. We just need a # transfer function which we can modify later LUT = simple.GetColorTransferFunction('HalliGalli') LUT.RGBPoints = [ -1e-10, 0.231373, 0.298039, 0.752941, 0, 1.0, 1.0, 1.0, 1e-10, 0.705882, 0.0156863, 0.14902 ] LUT.NanColor = [0.500008, 0.0, 0.0] LUT.ScalarRangeInitialized = 1.0 # get any opacity transfer function/opacity map # Not used so far PWF = simple.GetOpacityTransferFunction('HalliGalli') PWF.Points = [-1e-10, 0.0, 0.5, 0.0, 1e-10, 1.0, 0.5, 0.0] PWF.ScalarRangeInitialized = 1 # setup the color legend parameters for each legend in this view
class Pipeline: # Create data source "input" (provides simulation fields) simData = coprocessor.CreateProducer(datadescription, "input") # Write VTK output if requested if writeVtkOutput: fullWriter = pvs.XMLHierarchicalBoxDataWriter( Input=simData, DataMode="Appended", CompressorType="ZLib") # Set freq=1 to ensure that output is written whenever the pipeline runs coprocessor.RegisterWriter(fullWriter, filename='bg_out_%t.vth', freq=1) # Create a new render view to generate images renderView = pvs.CreateView('RenderView') renderView.ViewSize = [1500, 768] renderView.InteractionMode = '2D' renderView.AxesGrid = 'GridAxes3DActor' renderView.CenterOfRotation = [2.8, 1.7, 0.0] renderView.StereoType = 0 renderView.CameraPosition = [2.8, 1.7, 10000.0] renderView.CameraFocalPoint = [2.8, 1.7, 0.0] renderView.CameraParallelScale = 3.386 renderView.Background = [0.32, 0.34, 0.43] renderView.ViewTime = datadescription.GetTime() # Show simulation time with 1 digit after decimal point annotateTime = pvs.AnnotateTime() annotateTime.Format = 'time: %.1f' timeDisplay = pvs.Show(annotateTime, renderView) # Combine uu and vv components into velocity vector field calculatorVelField = pvs.Calculator(Input=simData) calculatorVelField.AttributeType = 'Cell Data' calculatorVelField.ResultArrayName = 'velocity' calculatorVelField.Function = 'uu*iHat+vv*jHat' # Compute velocity field magnitudes calculatorVelMag = pvs.Calculator(Input=calculatorVelField) calculatorVelMag.AttributeType = 'Cell Data' calculatorVelMag.ResultArrayName = 'mag' calculatorVelMag.Function = 'mag(velocity)' # Remove cells with vanishing velocity magnitude velMagThreshold = pvs.Threshold(calculatorVelMag) velMagThreshold.Scalars = ['CELLS', 'mag'] velMagThreshold.ThresholdRange = [1.0e-6, 1.0e30] # Visualise remaining velocity vector field using arrows with fixed length # and skipping cells to avoid crowding glyphs = pvs.Glyph(Input=velMagThreshold, GlyphType='Arrow') glyphs.Vectors = ['CELLS', 'velocity'] glyphs.ScaleFactor = 0.2 glyphs.GlyphMode = 'Every Nth Point' glyphs.Stride = 100 glyphs.GlyphTransform = 'Transform2' # Register the view with coprocessor and provide it with information such as # the filename to use. Set freq=1 to ensure that images are rendered whenever # the pipeline runs coprocessor.RegisterView(renderView, filename='bg_out_%t.png', freq=1, fittoscreen=0, magnification=1, width=1500, height=768, cinema={}) # Create colour transfer function for field LUT = pvs.GetColorTransferFunction('hh') LUT.RGBPoints = [ 9.355e-05, 0.231, 0.298, 0.753, 0.0674, 0.865, 0.865, 0.865, 0.135, 0.706, 0.0157, 0.149 ] LUT.ScalarRangeInitialized = 1.0 # Render data field and colour by field value using lookup table fieldDisplay = pvs.Show(simData, renderView) fieldDisplay.Representation = 'Surface' fieldDisplay.ColorArrayName = ['CELLS', 'hh'] fieldDisplay.LookupTable = LUT # Add velocity field visualisation velfieldDisplay = pvs.Show(glyphs, renderView)
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")
def updateUserSelectionLutProperties(self): lutProxy = simple.GetColorTransferFunction(USER_SELECTION) lutPwf = simple.GetOpacityTransferFunction(USER_SELECTION) if not lutProxy: print( 'There is no such color transfer function (%s) at this time' % USER_SELECTION) return if not lutPwf: print( 'There is no such opacity transfer function (%s) at this time' % USER_SELECTION) return preset = self.lutMap[SELECTION_COLORMAP]['IndexedColors'] if not preset: print('You are missing the "%s" color map definition' % SELECTION_COLORMAP) return activeAnnotation = self.activeSelectionInformation["activeAnnotation"] activeScores = self.activeSelectionInformation["activeScores"] annoType = activeAnnotation['selection']['type'] annoScore = activeAnnotation['score'] # append a 0 so unselected scores don't show by default. scoreOpacities = [ 1.0 if score['index'] in activeScores else 0.0 for score in self._serverScores ] + \ [1.0 if self._unselectedIndex in activeScores else 0.0] numScores = len(self._serverScores) pwfPoints = [] rgbPoints = [] delX = 0.49 # import pdb; pdb.set_trace() ### Inside the cases below I also need to create custom opacity and size pwfs for ### the "user selection" array ### We take into account the "activeScores" pushed here by the client ### so we can show/hide the appropriate subsets of points using a dedicated ### opacity transfer function on the lookup table usRange = [ self.userSelPointSizeRange[0], self.userSelPointSizeRange[1] ] usDelta = (usRange[1] - usRange[0]) / numScores # unselected value is last, should be the minimum value. sizeStops = [ usRange[0] + (i + 1) * usDelta for i in range(numScores - 1) ] + [usRange[1], usRange[0]] if annoType == 'range': scoreIndex = annoScore[0] rgbPoints = [] pwfPoints = [] self.userSelScalePoints = [] for selVal in [scoreIndex, self._unselectedIndex]: presetOffset = selVal * 3 # add the selected color rgbPoints += [selVal - delX ] + preset[presetOffset:presetOffset + 3] + [ selVal + delX ] + preset[presetOffset:presetOffset + 3] opacity = scoreOpacities[selVal] pwfPoints += [ selVal - delX, opacity, 0.5, 0.0, selVal + delX, opacity, 0.5, 0.0 ] self.userSelScalePoints += [ selVal - delX, sizeStops[selVal], 0.5, 0.0, selVal + delX, sizeStops[selVal], 0.5, 0.0 ] elif annoType == 'partition': self.userSelScalePoints = [] for idx in range(len(annoScore)): scoreIndex = annoScore[idx] presetOffset = scoreIndex * 3 x1 = scoreIndex - delX x2 = scoreIndex + delX opacity = scoreOpacities[scoreIndex] rgbPoints += [x1] + preset[presetOffset:presetOffset + 3] rgbPoints += [x2] + preset[presetOffset:presetOffset + 3] pwfPoints += [x1, opacity, 0.5, 0.0, x2, opacity, 0.5, 0.0] self.userSelScalePoints += [ x1, sizeStops[scoreIndex], 0.5, 0.0, x2, sizeStops[scoreIndex], 0.5, 0.0 ] elif annoType == 'empty': selVal = self._unselectedIndex opacity = scoreOpacities[selVal] rgbPoints = [selVal - delX] + preset[3 * selVal:3 * selVal + 3] + [ selVal + delX ] + preset[3 * selVal:3 * selVal + 3] pwfPoints = [ selVal - delX, opacity, 0.5, 0.0, selVal + delX, opacity, 0.5, 0.0 ] self.userSelScalePoints = [ selVal - delX, usRange[0], 0.5, 0.0, selVal + delX, usRange[0], 0.5, 0.0 ] else: print('Unknown annotation selection type: %s' % annoType) return # print('rgbPoints', rgbPoints) # print('pwfPoints', pwfPoints) lutProxy.RGBPoints = rgbPoints lutProxy.ScalarRangeInitialized = 1.0 if len(pwfPoints) > 0: lutPwf.Points = pwfPoints lutPwf.ScalarRangeInitialized = 1 lutProxy.EnableOpacityMapping = 1 else: lutProxy.EnableOpacityMapping = 0 self._selectionLutInitialized = True # Let PV know that the VTK data has been modified if self.trivProducer: self.trivProducer.MarkModified(self.trivProducer) self.getApplication().InvokeEvent('UpdateEvent')
class Pipeline: # Define source of pipeline grid = coprocessor.CreateProducer(datadescription, "input") if (write_full_output == True): fullWriter = pvs.XMLPUnstructuredGridWriter( Input=grid, DataMode="Appended", CompressorType="ZLib") coprocessor.RegisterWriter(fullWriter, filename='full_output_%t.pvtu', freq=1) # Create a spherical slice slice = pvs.Slice(Input=grid) slice.SliceType = 'Sphere' slice.Triangulatetheslice = 0 slice.SliceOffsetValues = [0.0] slice.SliceType.Radius = sphere_radius # Create writer for this data and register it with the pipeline sliceWriter = pvs.XMLPPolyDataWriter(Input=slice, DataMode="Appended", CompressorType="ZLib") coprocessor.RegisterWriter(sliceWriter, filename='spherical_slice_%t.pvtp', freq=1) # Create a new render view renderView = pvs.CreateView('RenderView') renderView.ViewSize = [1500, 768] renderView.AxesGrid = 'GridAxes3DActor' renderView.StereoType = 0 renderView.CameraPosition = [-5, -2, 4] renderView.CameraViewUp = [0.5, 0.3, 0.8] renderView.CameraParallelScale = 1.7 renderView.Background = [0.32, 0.34, 0.43] renderView.ViewTime = datadescription.GetTime() # Register the view with coprocessor # and provide it with information such as the filename to use, # how frequently to write the images, etc. coprocessor.RegisterView(renderView, filename='spherical_slice_%t.png', freq=1, fittoscreen=1, magnification=1, width=1500, height=768, cinema={}) # Create colour transfer function for field LUT = pvs.GetColorTransferFunction(fieldname) LUT.RGBPoints = [ dataRange[0], 0.23, 0.30, 0.75, 0.5 * sum(dataRange), 0.87, 0.87, 0.87, dataRange[1], 0.71, 0.016, 0.15 ] LUT.ScalarRangeInitialized = 1.0 # Show surface and colour by field value (which is cell data) using lookup table sphereDisplay = pvs.Show(slice, renderView) sphereDisplay.Representation = 'Surface' sphereDisplay.ColorArrayName = ['CELLS', fieldname] sphereDisplay.LookupTable = LUT
class Pipeline: grid = coprocessor.CreateProducer(datadescription, 'input') # Normalise radius - simplifies creating glyphs normalise = pvs.Calculator(Input=grid) normalise.CoordinateResults = 1 normalise.Function = 'coords/%i' % sphere_radius # Visualise velocity field using arrows glyph = pvs.Glyph(Input=normalise, GlyphType='Arrow') glyph.Scalars = ['POINTS', 'None'] glyph.Vectors = ['CELLS', 'u'] glyph.ScaleFactor = 0.2 glyph.GlyphTransform = 'Transform2' glyph.GlyphType.TipResolution = 12 glyph.GlyphType.TipRadius = 0.05 glyph.GlyphType.ShaftRadius = 0.015 # Create a new 'Render View' renderView = pvs.CreateView('RenderView') renderView.ViewSize = [1500, 768] renderView.AxesGrid = 'GridAxes3DActor' renderView.StereoType = 0 renderView.CameraPosition = [-5, -2, 4] renderView.CameraViewUp = [0.5, 0.3, 0.8] renderView.CameraParallelScale = 1.7 renderView.Background = [0.32, 0.34, 0.43] # Register the view with coprocessor # and provide it with information such as the filename to use, # how frequently to write the images, etc. coprocessor.RegisterView(renderView, filename='velocity_field_%t.png', freq=1, fittoscreen=1, magnification=1, width=800, height=800, cinema={}) renderView.ViewTime = datadescription.GetTime() # Create colour transfer function for velocity field uLUT = pvs.GetColorTransferFunction('u') uLUT.RGBPoints = [ 1.7, 0.23, 0.30, 0.75, 20.9, 0.87, 0.87, 0.87, 40.0, 0.71, 0.016, 0.15 ] uLUT.ScalarRangeInitialized = 1.0 # Show velocity field magnitude velocitymagDisplay = pvs.Show(normalise, renderView) velocitymagDisplay.Representation = 'Surface' velocitymagDisplay.ColorArrayName = ['CELLS', 'u'] velocitymagDisplay.LookupTable = uLUT # Show colour legend uLUTColorBar = pvs.GetScalarBar(uLUT, renderView) uLUTColorBar.Title = 'u' uLUTColorBar.ComponentTitle = 'Magnitude' velocitymagDisplay.SetScalarBarVisibility(renderView, True) # Show velocity field glyphs glyphDisplay = pvs.Show(glyph, renderView) glyphDisplay.Representation = 'Surface' glyphDisplay.ColorArrayName = [None, '']
class Pipeline: # Define source of pipeline grid = coprocessor.CreateProducer(datadescription, "input") if (write_full_output == True): fullWriter = pvs.XMLPUnstructuredGridWriter( Input=grid, DataMode="Appended", CompressorType="ZLib") coprocessor.RegisterWriter(fullWriter, filename='full_output_%t.pvtu', freq=1) # Create a spherical slice slice = pvs.Slice(Input=grid) slice.SliceType = 'Sphere' slice.Triangulatetheslice = 0 slice.SliceOffsetValues = [0.0] slice.SliceType.Radius = sphere_radius # Generate ghost cells - needed by CellDatatoPointData filter ghosts = pvs.GhostCellsGenerator(Input=grid) ghosts.BuildIfRequired = 0 ghosts.MinimumNumberOfGhostLevels = 1 # Convert cell data to point data, which is required for good contour results # Request "piece invariance" to ensure consistent values at # partition boundaries. # # CAUTION: THIS FILTER AVERAGES DATA FROM ALL CELLS SURROUNDING A POINT, # WHICH REDUCES ACCURACY cell2point = pvs.CellDatatoPointData(Input=ghosts) # Create contours # Note that the "tube" filter can be used to highlight contours if needed. contours = pvs.Contour(Input=cell2point) contours.Isosurfaces = contour_values contours.ContourBy = ['POINTS', 'rho'] contours.PointMergeMethod = 'Uniform Binning' # Create writers for slice and contour data and register them with the pipeline # Note that slice and contours generate separate datasets, so they need to be # written to separate files. sliceWriter = pvs.XMLPPolyDataWriter(Input=slice, DataMode="Appended", CompressorType="ZLib") coprocessor.RegisterWriter(sliceWriter, filename='spherical_slice_%t.pvtp', freq=1) # Create a new render view renderView = pvs.CreateView('RenderView') renderView.ViewSize = [1500, 768] renderView.AxesGrid = 'GridAxes3DActor' renderView.StereoType = 0 renderView.CameraPosition = [0.0, 1.0, 0.3] renderView.CameraViewUp = [0.0, 0.0, 1.0] renderView.CameraParallelScale = 1.0 renderView.Background = [0.32, 0.34, 0.43] renderView.ViewTime = datadescription.GetTime() # Register the view with coprocessor # and provide it with information such as the filename to use, # how frequently to write the images, etc. coprocessor.RegisterView(renderView, filename='contours_%t.png', freq=1, fittoscreen=1, magnification=1, width=1500, height=768, cinema={}) # Create colour transfer function for field LUT = pvs.GetColorTransferFunction('rho') LUT.RGBPoints = [ dataRange[0], 0.23, 0.30, 0.75, 0.5 * sum(dataRange), 0.87, 0.87, 0.87, dataRange[1], 0.71, 0.016, 0.15 ] LUT.ScalarRangeInitialized = 1.0 # Show surface and colour by field value (which is cell data) using lookup table sphereDisplay = pvs.Show(slice, renderView) sphereDisplay.Representation = 'Surface' sphereDisplay.ColorArrayName = ['CELLS', 'rho'] sphereDisplay.LookupTable = LUT # Show coastlines contourDisplay = pvs.Show(contours, renderView) contourDisplay.Representation = 'Surface' contourDisplay.ColorArrayName = [None, ''] contourDisplay.OSPRayScaleArray = 'theta ' contourDisplay.OSPRayScaleFunction = 'PiecewiseFunction' contourDisplay.SelectOrientationVectors = 'None' contourDisplay.ScaleFactor = 1193042.2418936265 contourDisplay.SelectScaleArray = 'None' contourDisplay.GlyphType = 'Arrow' contourDisplay.GlyphTableIndexArray = 'None' contourDisplay.DataAxesGrid = 'GridAxesRepresentation' contourDisplay.PolarAxes = 'PolarAxesRepresentation' contourDisplay.GaussianRadius = 596521.1209468133 contourDisplay.SetScaleArray = ['POINTS', 'theta '] contourDisplay.ScaleTransferFunction = 'PiecewiseFunction' contourDisplay.OpacityArray = ['POINTS', 'theta '] contourDisplay.OpacityTransferFunction = 'PiecewiseFunction'
# set active view pv.SetActiveView(renderView1) # create a new 'Glyph' # sphere glyph1 = pv.Glyph(Input=tableToPoints1, GlyphType='Sphere') glyph1.Scalars = ['POINTS', 'Q'] glyph1.ScaleMode = 'scalar' glyph1.ScaleFactor = scaleFactor glyph1.GlyphMode = 'All Points' #glyph1.GlyphType.ThetaResolution = 8 #glyph1.GlyphType.PhiResolution = 8 # get color transfer function/color map for args.colourColumn cLUT = pv.GetColorTransferFunction(args.colourColumn) nc = vtk.vtkNamedColors() rgb = [0. for i in range(3)] if args.colourColumn == 'Q': cLUT.ApplyPreset("Plasma (matplotlib)") else: nc.GetColorRGB("Magenta", rgb) rgbPoints = [-1.] + rgb # Rejected Hit nc.GetColorRGB("Lime", rgb) rgbPoints += [0.] + rgb # Unambiguous Hit if args.detail: nc.GetColorRGB("Green", rgb) else: nc.GetColorRGB("Lime", rgb) rgbPoints += [1.] + rgb # Accepted Ambiguity nc.GetColorRGB("Maroon", rgb)
def batchVis(c1File,particleFile,step,saveAs): """Renders a bijel top down view in paraview and saves a screenshot.""" import paraview.simple as pv # visualize a vtk file c1 = pv.LegacyVTKReader(FileNames=c1File) p = pv.LegacyVTKReader(FileNames=particleFile) renderView1 = pv.GetActiveViewOrCreate('RenderView') renderView1.ViewSize = [1298, 860] renderView1.Background = [1.0, 1.0, 1.0] renderView1.InteractionMode = '2D' pDisplay = pv.Show(p, renderView1) c1Display = pv.Show(c1, renderView1) # create particle glyphs glyph = pv.Glyph(Input=p,GlyphType="Sphere") glyph.ScaleFactor = 1.0 glyph.GlyphMode = 'All Points' glyph.GlyphType.Radius = 1.0 glyph.GlyphType.ThetaResolution = 20 glyph.GlyphType.PhiResolution = 20 glyph.Scalars = ['POINTS','radius'] glyph.Vectors = ['POINTS','None'] glyph.ScaleMode = 'scalar' # show data in view glyphDisplay = pv.Show(glyph, renderView1) pv.ColorBy(glyphDisplay, None) pv.SetActiveSource(c1) pv.ColorBy(c1Display, ('POINTS', 'c1')) c1Display.RescaleTransferFunctionToDataRange(True) c1Display.SetRepresentationType('Volume') # make box outline # box = pv.Box() # box.XLength = 128.0 # box.YLength = 128.0 # box.ZLength = 64.0 # box.Center = [64.0, 64.0, 32.0] # boxDisplay = pv.Show(box, renderView1) # boxDisplay.SetRepresentationType('Outline') # boxDisplay.AmbientColor = [0.0, 0.0, 0.0] # set coloring of c1 c1LUT = pv.GetColorTransferFunction('c1') c1LUT.RGBPoints = [0.006000000052154064, 0.231373, 0.298039, 0.752941, 0.5120000033639371, 0.865003, 0.865003, 0.865003, 1.0180000066757202, 0.705882, 0.0156863, 0.14902] c1LUT.ColorSpace = 'Diverging' c1LUT.BelowRangeColor = [0.0, 0.0, 0.0] c1LUT.AboveRangeColor = [1.0, 1.0, 1.0] c1LUT.NanColor = [1.0, 1.0, 0.0] c1LUT.Discretize = 1 c1LUT.NumberOfTableValues = 256 c1LUT.ScalarRangeInitialized = 1.0 c1LUT.AllowDuplicateScalars = 1 c1PWF = pv.GetOpacityTransferFunction('c1') c1PWF.Points = [0.0, 0.05, 0.5, 0.0, 0.3, 0.05, 0.5, 0.0, 0.4, 0.5, 0.5, 0.0, 0.6, 0.5, 0.5, 0.0, 0.7, 0.05, 0.5, 0.0, 1., 0.05, 0.5, 0.0] # annotate time step in rendering # text = pv.Text # text.Text = 'Step '+str(step) # textDisplay = pv.Show(text,renderView1) # textDisplay.Color = [0.0, 0.0, 0.0] # textDisplay.WindowLocation = 'UpperCenter' # reset view to fit data renderView1.ResetCamera() # pv.Render() # save screen shot viewLayout1 = pv.GetLayout() print(saveAs) pv.SaveScreenshot(saveAs, layout=viewLayout1, magnification=1, quality=100) # clean up # pv.Delete(box) pv.Delete(glyph) pv.Delete(p) pv.Delete(c1) del c1 del p del glyph
def pvd_to_mp4(sim_dir, path_to_movies, movie_name='movie', representation='Surface', num_regions=0): ############################### # Validate directory and data # ############################### if not (os.path.isdir(sim_dir)): raise Exception('pvd_to_mp4: Invalid simulation directory') if not (os.path.isdir(path_to_movies)): raise Exception('pvd_to_mp4: Invalid movie directory') if representation not in ['Surface', 'Points']: raise Exception( 'pvd_to_mp4: Representation must be either Surface or Points') if num_regions not in [0, 9]: raise Exception( 'pvd_to_mp4: Currently there is only support for 9 node regions') # sim_id = os.path.basename(os.path.normpath(sim_dir)) possible_data_directories = [] for directory in os.listdir(sim_dir): if directory.startswith('results_from_time'): possible_data_directories.append(os.path.join(sim_dir, directory)) if len(possible_data_directories) == 0: raise Exception( 'pvd_to_mp4: Could not find a "results_from_time_X" directory') # The last directory alphabetically will be the one after any initial relaxation simulation data_directory = sorted(possible_data_directories)[-1] # Get the location of the pvd file pvd_file = os.path.join(data_directory, 'results.pvd') if not (os.path.isfile(pvd_file)): raise Exception('pvd_to_mp4: Could not find a pvd data file') if os.path.getsize(pvd_file) < 1024: raise Exception( 'pvd_to_mp4: pvd file exists but is < 1kb. Presumably simulation failed to finish as expected.' ) full_movie_path = os.path.join(path_to_movies, movie_name + '_' + representation + '.mp4') ################################## # Set up scene with box and data # ################################## # Get active view. This is the ParaView default view - blue background with cross hairs and orientation axes render_view = pv.GetActiveViewOrCreate('RenderView') # Change parameters to be how we want them for output render_view.ViewSize = [1600, 900] # Size of output (pixels) render_view.CenterAxesVisibility = 0 # Remove cross hairs render_view.OrientationAxesVisibility = 0 # Remove orientation axes render_view.Background = [0.5, 0.5, 0.5] # Set background colour to 50% grey # Create a unit square (a 3D Box with ZLength set to zero) unit_square = pv.Box() unit_square.ZLength = 0.0 unit_square.YLength = 9.0 / 16.0 unit_square.Center = [0.5, 0.5, 0.0] # Show the box in the current render view, and colour it black unit_square_display = pv.Show(unit_square, render_view) unit_square_display.DiffuseColor = [0.0, 0.0, 0.0] # Read the relevant pvd file from the Chaste output results_pvd = pv.PVDReader(FileName=pvd_file) # Show the data in the current render view as a surface results_pvd_display = pv.Show(results_pvd, render_view) results_pvd_display.Representation = representation if representation == 'Points' and num_regions == 9: pv.ColorBy(results_pvd_display, ('POINTS', 'Node Regions')) node_regions_lut = pv.GetColorTransferFunction('NodeRegions') # Each four digits are: data value, r, g, b (colour) node_regions_lut.RGBPoints = [ 0.0, 1.00, 0.00, 0.00, # LEFT_APICAL_REGION, red 1.0, 1.00, 0.00, 0.00, # RIGHT_APICAL_REGION, red 2.0, 1.00, 0.00, 1.00, # LEFT_PERIAPICAL_REGION, purple 3.0, 1.00, 0.00, 1.00, # RIGHT_PERIAPICAL_REGION, purple 4.0, 0.00, 0.00, 1.00, # LEFT_LATERAL_REGION, blue 5.0, 0.00, 0.00, 1.00, # RIGHT_LATERAL_REGION, blue 6.0, 1.00, 1.00, 1.00, # LEFT_BASAL_REGION, white 7.0, 1.00, 1.00, 1.00, # RIGHT_BASAL_REGION, white 8.0, 1.00, 1.00, 1.00 ] # LAMINA_REGION, white cell_regions_lut = pv.GetColorTransferFunction('CellRegions') cell_regions_lut.RGBPoints = [ -1.0, 0.0, 0.00, 0.00, # basal lamina, black 0.0, 0.00, 0.00, 1.00, # left region, blue 1.0, 1.00, 1.00, 1.00, # centre_region, white 2.0, 1.00, 0.00, 0.00 ] # right_region, red # Glyphs for cell region cell_glyphs = pv.Glyph(Input=results_pvd, GlyphType='2D Glyph') cell_glyphs.Scalars = ['CELLS', 'Cell Regions'] cell_glyphs.ScaleFactor = 0.01 cell_glyphs.GlyphMode = 'All Points' cell_glyphs.GlyphType.GlyphType = 'Diamond' cell_glyphs.GlyphType.Filled = 1 cell_glyphs.GlyphTransform.Scale = [1.0, 2.0, 1.0] cell_glyphs_display = pv.Show(cell_glyphs, render_view) cell_glyphs_display.Opacity = 0.5 # Glyphs for node region node_glyphs = pv.Glyph(Input=results_pvd, GlyphType='2D Glyph') node_glyphs.Scalars = ['POINTS', 'Node Regions'] node_glyphs.ScaleFactor = 0.002 node_glyphs.GlyphMode = 'All Points' node_glyphs.GlyphType.GlyphType = 'Circle' node_glyphs.GlyphType.Filled = 1 pv.Show(node_glyphs, render_view) ################################### # Put the camera where we want it # ################################### # This happens after all calls to Show, as Show may do some automatic camera re-setting render_view.InteractionMode = '2D' render_view.CameraPosition = [0.5, 0.5, 1.0] render_view.CameraFocalPoint = [0.5, 0.5, 0.0] # This parameter sets the 'zoom' and needs fine-tuning by the aspect ratio render_view.CameraParallelScale = 0.5 * 9.0 / 16.0 ################################## # Set up and write the animation # ################################## # Get an animation scene, which has parameters we need to change before output animation_scene = pv.GetAnimationScene() # Get a list of time step values from the pvd file. Typically this will look like [t_0, t1, t2, ..., t_end] time_step_info = results_pvd.TimestepValues num_time_steps = len(time_step_info) # Set the animation parameters animation_scene.NumberOfFrames = num_time_steps # If num frames != num time steps, some interpolation will be used animation_scene.StartTime = time_step_info[ 0] # Usually t_0, the first entry in time_step_info animation_scene.EndTime = time_step_info[ -1] # Usually t_end, the final entry in time_step_info # Write the animation as a series of uncompressed png files, with no magnification pv.WriteAnimation(sim_dir + 'results_' + representation + '.png', Magnification=1, Compression=False) # Raise exception if the png files are not generated as expected if not (os.path.isfile(sim_dir + 'results_' + representation + '.0000.png')): raise Exception('pvd_to_mp4: png sequence not exported as expected') ####################################### # Convert from png to mp4 and tidy up # ####################################### # Ubuntu 14.04 (trusty) came bundled with avconv instead of ffmpeg, but they're nearly the same software # so we don't have to change the command other than the name of the video converter to use if platform.linux_distribution()[2] == 'trusty': video_converter = 'avconv' else: video_converter = 'ffmpeg' # Set how long you want the video to be (in seconds), and set the frame rate accordingly video_duration = 15.0 frame_rate = str(num_time_steps / video_duration) # Send the system command to run avconv/ffmpeg. Parameters: # -v 0 Suppress console output so as not to clutter the terminal # -r frame_rate Set the frame rate calculated above # -f image2 Set the convert format (image sequence to video) # -i dir/results.%04d.png Input expected as dir/results.####.png, the output from WriteAnimation above # -c:v h264 Video codec to use is h264 # -crf 0 Set video quality: 0 best, 51 worst (https://trac.ffmpeg.org/wiki/Encode/H.264) # -y dir/movie.mp4 Output directory and name os.system(video_converter + ' -v 0 -r ' + frame_rate + ' -f image2 -i ' + sim_dir + 'results_' + representation + '.%04d.png -c:v h264 -crf 0 -y ' + full_movie_path) # Raise exception if the mp4 file is not generated as expected if not (os.path.isfile(full_movie_path)): raise Exception('pvd_to_mp4: mp4 not generated as expected') # Raise exception if the mp4 file file is created but is smaller than 1kb - ffmpeg sometimes # generates an empty file even if an error occurs if os.path.getsize(full_movie_path) < 1024: raise Exception('pvd_to_mp4: mp4 not generated as expected') # Clean up the png files created by WriteAnimation os.system('rm ' + sim_dir + '*.png')