def loadData(self): global dataPath mainpath = os.path.join(dataPath, "main") if os.path.isdir(mainpath): files = os.listdir(mainpath) for file in files: fullpath = os.path.join(mainpath, file) if os.path.isfile(fullpath): self.srcObj = simple.OpenDataFile(fullpath) simple.SetActiveSource(self.srcObj) self.rep = simple.GetDisplayProperties() simple.Hide() print 'Loaded %s into scene' % fullpath else: print 'Error: ' + mainpath + ' does not exist\n' raise Exception("The main directory does not exist") surfacespath = os.path.join(dataPath, "surfaces") files = os.listdir(surfacespath) for file in files: fullpath = os.path.join(surfacespath, file) if os.path.isfile(fullpath): self._loadSurfaceWithProperties(fullpath) simple.SetActiveSource(self.srcObj) simple.ResetCamera() simple.Render()
def createTemporalTransformsAxes(source="default", renderView="default"): """ Display orientation part of a TemporalTransforms Allow visualizing the orientations part of the TemporalTransforms by displaying the x, y and z unitary vector of the sensor reference frame. The source must provide transforms, for example it could be: a TemporalTransformReader, or the trajectory output of Lidar SLAM ParaView pipeline elements are created. These elements can be deleted using function deleteAllTemporalTransformsAxes(). """ # GetActiveSource() and GetRenderView() do not work if used as default # parameter value, so they are called here if needs be: if source == "default": source = smp.GetActiveSource() if renderView == "default": renderView = smp.GetRenderView() smp.SetActiveSource(source) # maybe useless calculatorX = setupCalculator(source, "RX", [1.0, 0.0, 0.0], fx, renderView) calculatorY = setupCalculator(source, "RY", [0.0, 1.0, 0.0], fy, renderView) calculatorZ = setupCalculator(source, "RZ", [0.0, 0.0, 1.0], fz, renderView) smp.Render()
def addSource(self, algo_name, parent): pid = str(parent) parentProxy = helper.idToProxy(parent) if parentProxy: simple.SetActiveSource(parentProxy) else: pid = '0' # Create new source/filter cmdLine = 'simple.' + algo_name + '()' newProxy = eval(cmdLine) # Create its representation and render simple.Show() simple.Render() simple.ResetCamera() # Add node to pipeline self.pipeline.addNode(pid, newProxy.GetGlobalIDAsString()) # Handle domains helper.apply_domains(parentProxy, newProxy.GetGlobalIDAsString()) # Create LUT if need be if pid == '0': self.lutManager.registerFieldData( newProxy.GetPointDataInformation()) self.lutManager.registerFieldData( newProxy.GetCellDataInformation()) # Return the newly created proxy pipeline node return helper.getProxyAsPipelineNode(newProxy.GetGlobalIDAsString(), self.lutManager)
def probe(self, variable, point): """Return the value of a variable at a given point. Args: variable (str): Name of the variable. Probing a vector return its magnitude. Components of the vector are available by adding a suffix ' X', ' Y' or ' Z' to the vector name. Physical coordinates are available under the name 'X', 'Y' or 'Z'. point (tuple): x, y and z coordinates. Returns: float: Queried value or None. None is returned if the variable does not exist or the point is not defined at the given point. """ pvs.SetActiveSource(self.reader) prob_loc = pvs.ProbeLocation(ProbeType="Fixed Radius Point Source") prob_loc.ProbeType.Center = point array = _get_variable_array(prob_loc, variable) pvs.Delete(prob_loc) if array is None or len(array) == 0: return None elif len(array) != 1: raise Exception("Unexpected length of the array.") else: return array[0]
def line(self, variable, line, npoints=100, only_inside=True): """Return a list of the variable values along the line. Args: variable (str): Name of the variable. See :py:meth:`DataSource.probe` for details. line (tuple): Tuple (point1, point2), where point1 and point2 are three-float tuples representing the coordinates of the start and end point of the line. npoints (int): Number of points along the line. only_inside (bool): True if the values outside of the defined data should be excluded. Otherwise, return NaN for these points. If True, length of the returned array could differ from npoints. Returns: numpy.ndarray: Variable values or None, if the variable does not exist. """ pvs.SetActiveSource(self.reader) pol = pvs.PlotOverLine(Source="High Resolution Line Source") pol.Source.Resolution = npoints - 1 pol.Source.Point1 = line[0] pol.Source.Point2 = line[1] array = _get_variable_array(pol, variable, only_inside) return array
def compute(self): if self.pvInstance: del self.pvInstance pv.SetActiveSource(None) if not self.pvInstance: if hasattr(self, "pvFunction"): self.pvInstance = self.pvFunction() else: self.pvInstance = getattr(pv, self.pvClass)() # We need to set input before other properties if self.inputPorts.has_key('Input'): inp = extract_pv_instances( self.forceGetInputListFromPort('Input'))[0] setattr(self.pvInstance, "Input", inp) for (function, connector_list) in self.inputPorts.iteritems(): paramList = extract_pv_instances( self.forceGetInputListFromPort(function)) if function != 'Input': if len(paramList) > 1: setattr(self.pvInstance, function, paramList) else: setattr(self.pvInstance, function, paramList[0]) if hasattr(self.pvInstance, 'UpdatePipeline'): self.pvInstance.UpdatePipeline() self.setResult('Output', self)
def extractSubgrid(self, bounds): if (self.subgrid is not None): simple.Delete(self.subgrid) simple.SetActiveSource(self.srcObj) self.subgrid = simple.ExtractSubset() self.subgrid.VOI = bounds simple.SetActiveSource(self.subgrid) self.rep = simple.Show() self.rep.ScalarOpacityFunction = self.sof self.rep.ColorArrayName = self.colorArrayName self.rep.Representation = 'Volume' self.rep.SelectionPointFieldDataArrayName = self.colorArrayName self.rep.LookupTable = self.lookupTable simple.Hide(self.srcObj) simple.SetActiveSource(self.subgrid) simple.Render()
def _sliceSurfaces(self, slice): if self.meshSlice is not None: simple.Delete(self.meshSlice) self.meshSlice = None for surface in self.surfaces: rep = simple.Show(surface) if self.sliceMode == 'XY Plane': origin = [ 0.0, 0.0, math.cos(math.radians(rep.Orientation[2])) * slice ] normal = [0.0, 0.0, 1.0] elif self.sliceMode == 'XZ Plane': origin = [ 0.0, math.cos(math.radians(rep.Orientation[1])) * slice, 0.0 ] normal = [0.0, 1.0, 0.0] else: origin = [ math.cos(math.radians(rep.Orientation[0])) * slice, 0.0, 0.0 ] normal = [1.0, 0.0, 0.0] simple.Hide(surface) self.meshSlice = simple.Slice(Input=surface, SliceType='Plane') simple.SetActiveSource(self.srcObj) self.meshSlice.SliceOffsetValues = [0.0] self.meshSlice.SliceType = 'Plane' self.meshSlice.SliceType.Origin = origin self.meshSlice.SliceType.Normal = normal meshDataRep = simple.Show(self.meshSlice) meshDataRep.Representation = 'Points' meshDataRep.LineWidth = self.CONTOUR_LINE_WIDTH meshDataRep.PointSize = self.CONTOUR_LINE_WIDTH meshDataRep.AmbientColor = rep.DiffuseColor meshDataRep.Orientation = rep.Orientation simple.SetActiveSource(self.srcObj)
def fitPlane(): src = smp.GetActiveSource() selection = GetSelectionSource(src) if not selection: return extracter = smp.ExtractSelection() extracter.Selection = selection extracter.Input = src smp.Show(extracter) try: pd = extracter.GetClientSideObject().GetOutput() origin = range(3) normal = range(3) mind, maxd, stddev = vtk.mutable(0), vtk.mutable(0), vtk.mutable(0) channelMean = range(32) channelStdDev = range(32) channelNpts = range(32) vvmod.vtkPlaneFitter.PlaneFit(pd, origin, normal, mind, maxd, stddev, channelMean, channelStdDev, channelNpts) rows = [['overall', origin, normal, 0.0, stddev, stddev, pd.GetNumberOfPoints()]] rows = rows + [['%d' % i, origin, normal, channelMean[i], channelStdDev[i], math.sqrt(channelMean[i]**2 + channelStdDev[i]**2), channelNpts[i]] for i in range(32)] def rowconverter(x): try: return '\t'.join(['%.4f' % d for d in x]) except TypeError: try: x = x.get() except AttributeError: pass if type(x) == float: return '%.4f' % x elif type(x) in (int, long): return '%d' % x else: return x print '\t'.join(['channel','originx','originy','originz','normalx','normaly','normalz', 'mean','stddev','RMS','npts']) for r in rows: if r[-1] == 0: r[-4:-1] = ['nan', 'nan', 'nan'] print '\t'.join([rowconverter(x) for x in r]) finally: smp.Delete(extracter) smp.SetActiveSource(src)
def test_RenameSource(self): source = simple.Sphere(guiName='oldName') simple.SetActiveSource(source) simple.RenameSource('newName') # changing the source name should unregister the old name self.assertEqual(None, self.pxm.GetProxy('sources', 'oldName')) self.assertEqual(source, self.pxm.GetProxy('sources', 'newName')) # renaming as the current name should not unregister the source simple.RenameSource('newName') self.assertEqual(source, self.pxm.GetProxy('sources', 'newName'))
def showSphere(self, params): if self.sphere is not None: simple.Delete(self.sphere) maxDim = max(self.bounds[1] - self.bounds[0], self.bounds[3] - self.bounds[2], self.bounds[5] - self.bounds[4]) self.sphere = simple.Sphere() self.sphere.Radius = maxDim / 100.0 self.sphere.Center = params['point'] rep = simple.Show() rep.Representation = 'Surface' rep.DiffuseColor = params['color'] simple.SetActiveSource(self.srcObj)
def drawCone(self): ################################################## # create a new Cone object self.cone1 = simple.Cone() ## In a Paraview Trace recorded session, the 'simple.' object is ## not necessary. Take your Trace output and add 'simple.' to all ## the capitalized functions and add 'self.' to the local ## variables, and try just dropping it in here. # set active source simple.SetActiveSource(self.cone1) # get active view self.renderView1 = simple.GetActiveViewOrCreate('RenderView') # show data in view self.cone1Display = simple.Show(self.cone1, self.renderView1) # trace defaults for the display properties. self.cone1Display.Representation = 'Surface' # reset view to fit data self.renderView1.ResetCamera() # Properties modified on cone1 self.cone1.Resolution = 12 # change solid color self.cone1Display.DiffuseColor = [0.666, 0.0, 1.0] # reset view to fit data self.renderView1.ResetCamera() # update the view to ensure updated data information self.renderView1.Update() # current camera placement for renderView1 self.renderView1.CameraPosition = [1.25, -3.0, -0.4] self.renderView1.CameraViewUp = [0.75, 0.2, 0.6] self.renderView1.CameraParallelScale = 0.85
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 boundary_line(self, variable, plane_point, plane_normal, bounding_box=None): """ Return a list of the variable values along the intersection of the domain boundary with a plane. Args: variable (str): Name of the variable. See :py:meth:`DataSource.probe` for details. plane_point (tuple): three-float tuple representing the point on the plane. plane_normal (tuple): three-float tuple representing the normal of the plane. bounding_box (tuple): Tuple (minx, miny, minz, maxx, maxy, maxz), where the values are the limits of the bounding box. Each point can be replaced by None if the appropriate bound is missing. Returns: numpy.ndarray: Variable values or None, if the variable does not exist. """ pvs.SetActiveSource(self.reader) poic = pvs.PlotOnIntersectionCurves(Input=self.reader) poic.SliceType = 'Plane' poic.SliceType.Origin = plane_point poic.SliceType.Normal = plane_normal latest = poic if bounding_box: latest = _add_bounding_box(latest, bounding_box) array = _get_variable_array(latest, variable, True) return array
def ArrowsScript(Input1, Input2, Output, CamDirVec=None, CamUpVec=None): #### disable automatic camera reset on 'Show' pvs._DisableFirstRenderCameraReset() # create a new 'XML Unstructured Grid Reader' VTU1 = pvs.XMLUnstructuredGridReader(FileName=[Input1]) VTU1.PointArrayStatus = ['Curvature'] # create a new 'XML Unstructured Grid Reader' VTU2 = pvs.XMLUnstructuredGridReader(FileName=[Input2]) VTU2.PointArrayStatus = ['Curvature'] # get active view renderView1 = pvs.GetActiveViewOrCreate('RenderView') # show data in view VTU1Display = pvs.Show(VTU1, renderView1) VTU1Display.Representation = 'Surface' VTU1Display.Diffuse = 0.85 VTU1Display.Ambient = 0.25 makeGlyph(VTU1, renderView1, scale=40.0, color=[1.0, 0.0, 0.0]) makeGlyph(VTU2, renderView1, scale=30.0, color=[0.0, 0.0, 1.0]) # Save Screenshot AdjustCameraAndSave(renderView1, Output, ImageResolution=(2048, 2048), CamDirVec=CamDirVec, CamUpVec=CamUpVec) # set active source pvs.SetActiveSource(None) pvs.SetActiveView(None) pvs.Disconnect()
def updateEventCb(self, obj, event): name = self._getSourceToExtractName(obj) if not self.source: self.source = simple.FindSource(name) simple.SetActiveSource(self.source) if self.source and not self.rep: self.outline = simple.Outline(self.source) self.rep = simple.Show(self.source) self.outline.UpdatePipeline() self.outlineRep = simple.Show(self.outline) # TODO: this is for the demo # TODO: what would be the best way to change sources and representations from the client ? # create a protocol for liveInsituLink.GetInsituProxyManager() ? # or setActiveSource endpoint ? # or is there a better way ? info = self.source.GetPointDataInformation() if info.GetNumberOfArrays() > 0: arrName = info.GetArray(0).Name self.rep.ColorArrayName = ['POINTS', arrName] simple.ColorBy(self.rep, arrName) # Point gaussian props = simple.GetDisplayProperties(self.source) props.SetRepresentationType('Point Gaussian') props.GaussianRadius = 0.01
raise WrongInput('Source has no information, uncomplete.') composite_class = info.GetCompositeDataClassName() if composite_class is None or not composite_class == 'vtkMultiBlockDataSet': raise WrongInput( 'Source produce wrong type of data. MultiBlockDataSet required.') # make a filter to collect all well lines in order # to workaround a bug that do not porduce selsection labels # on composite datasets merged = ps.ProgrammableFilter() merged.Script = merge_groups_script merged.OutputDataSetType = 0 # PolyData merged.Input = source # update pipeline in order to get total number of points ps.SetActiveSource(merged) ps.UpdatePipeline() # make selection where to show labels n_points = merged.GetDataInformation().DataInformation.GetNumberOfPoints() selection = ps.IDSelectionSource() IDs = [] for i in range(n_points): # select only non-head points IDs.append(0L) IDs.append(long(i)) selection.IDs = IDs selection.FieldType = 1 # select point merged.SetSelectionInput(0, selection, 0) # get representation and select its selection properties
def execute(self): self.cdms_variables = self.forceGetInputListFromPort('cdms_variable') for cdms_var in self.cdms_variables: #// @todo: hardcoded for now time_values = [None, 1, True] #// Get the min and max to draw default contours min = cdms_var.var.min() max = cdms_var.var.max() reader = PVCDMSReader() image_data = reader.convert(cdms_var, time=time_values) #// Make white box filter so we can work at proxy level programmable_source = pvsp.ProgrammableSource() #// Get a hole of the vtk level filter it controls ps = programmable_source.GetClientSideObject() #// Give it some data (ie the imagedata) ps.myid = image_data programmable_source.OutputDataSetType = 'vtkImageData' programmable_source.PythonPath = '' #// Make the scripts that it runs in pipeline RI and RD passes programmable_source.ScriptRequestInformation = """ executive = self.GetExecutive() outInfo = executive.GetOutputInformation(0) extents = self.myid.GetExtent() spacing = self.myid.GetSpacing() outInfo.Set(executive.WHOLE_EXTENT(), extents[0], extents[1], extents[2], extents[3], extents[4], extents[5]) outInfo.Set(vtk.vtkDataObject.SPACING(), spacing[0], spacing[1], spacing[2]) dataType = 10 # VTK_FLOAT numberOfComponents = 1 vtk.vtkDataObject.SetPointDataActiveScalarInfo(outInfo, dataType, numberOfComponents)""" programmable_source.Script = """self.GetOutput().ShallowCopy(self.myid)""" programmable_source.UpdatePipeline() pvsp.SetActiveSource(programmable_source) self.slice_by_var_name = cdms_var.varname self.slice_by_var_type = 'POINTS' if not reader.is_three_dimensional(cdms_var): data_rep = pvsp.Show(view=self.view) data_rep.LookupTable = pvsp.GetLookupTableForArray( self.slice_by_var_name, 1, NanColor=[0.25, 0.0, 0.0], RGBPoints=[ min, 0.23, 0.299, 0.754, max, 0.706, 0.016, 0.15 ], VectorMode='Magnitude', ColorSpace='Diverging', LockScalarRange=1) data_rep.ColorArrayName = self.slice_by_var_name continue functions = [] try: slice_origin = self.forceGetInputListFromPort("slice_origin") if (slice_origin == None) or len(slice_origin) == 0: bounds = image_data.GetBounds() self.slice_origin = [] self.slice_origin.append((bounds[1] + bounds[0]) / 2.0) self.slice_origin.append((bounds[3] + bounds[2]) / 2.0) self.slice_origin.append((bounds[5] + bounds[4]) / 2.0) functions.append( ('slice_origin', [str(self.slice_origin).strip('[]')])) else: self.slice_origin = [ float(d) for d in slice_origin[0].split(',') ] slice_normal = self.forceGetInputListFromPort("slice_normal") if slice_normal == None or len(slice_normal) == 0: self.slice_normal = [0.0, 0.0, 1.0] functions.append( ('slice_normal', [str(self.slice_normal).strip('[]')])) else: self.slice_normal = [ float(d) for d in slice_normal[0].split(',') ] slice_offset_values = self.forceGetInputListFromPort( "slice_offset_values") if (len(slice_offset_values) and slice_offset_values): self.slice_offset_values = [ float(d) for d in slice_offset_values[0].split(',') ] else: self.slice_offset_values = [0.0] functions.append( ('slice_offset_values', [str(self.slice_offset_values).strip('[]')])) if len(functions) > 0: self.update_functions('PVSliceRepresentation', functions) #// Create a slice representation plane_slice = pvsp.Slice(SliceType="Plane") pvsp.SetActiveSource(plane_slice) plane_slice.SliceType.Normal = self.slice_normal plane_slice.SliceType.Origin = self.slice_origin plane_slice.SliceOffsetValues = self.slice_offset_values slice_rep = pvsp.Show(view=self.view) slice_rep.LookupTable = pvsp.GetLookupTableForArray( self.slice_by_var_name, 1, NanColor=[0.25, 0.0, 0.0], RGBPoints=[ min, 0.23, 0.299, 0.754, max, 0.706, 0.016, 0.15 ], VectorMode='Magnitude', ColorSpace='Diverging', LockScalarRange=1) slice_rep.ColorArrayName = self.slice_by_var_name slice_rep.Representation = 'Surface' #// Scalar bar ScalarBarWidgetRepresentation1 = pvsp.CreateScalarBar( Title=self.slice_by_var_name, LabelFontSize=12, Enabled=1, TitleFontSize=12) self.view.Representations.append( ScalarBarWidgetRepresentation1) if not reader.is_three_dimensional(cdms_var): ScalarBarWidgetRepresentation1.LookupTable = data_rep.LookupTable else: ScalarBarWidgetRepresentation1.LookupTable = slice_rep.LookupTable except ValueError: print "[ERROR] Unable to generate slice. Please check your input values" except (RuntimeError, TypeError, NameError): print "[ERROR] Unknown error"
def StreamlinesScript(Input1, Input2, Output, N1=None, N2=None, Offset1=0.0, Offset2=0.0, CamDirVec=None, CamUpVec=None, Origin=None): ''' Creates an image with the streamlines from two VTUs. Inputs: Input1 - VTU with first direction of curvatures Input2 - VTU with second direction of curvatures N1 - List of normal of slice for VTU1 N2 - List of normal of slice for VTU2 Offset1 - Value of offset for slice of VTU1 Offset2 - Value of offset for slice of VTU2 CamDirVec - Vector for camera direction CamUpVec - Vector for camera up direction Origin - Vector with the position for the origin''' #### disable automatic camera reset on 'Show' pvs._DisableFirstRenderCameraReset() # create a new 'XML Unstructured Grid Reader' VTU1 = pvs.XMLUnstructuredGridReader(FileName=[Input1]) VTU1.PointArrayStatus = ['Curvature'] ## Fix data for Slices if N1 is None: N1 = [0.9, 0.4, 0.2] if N2 is None: # N2 = np.cross(N1,[0,0,1]) N2 = [-0.8, 0.5, 0.16] if Origin is None: Origin = paraview.servermanager.Fetch( pvs.IntegrateVariables(Input=VTU1)).GetPoint(0) # create a new 'XML Unstructured Grid Reader' VTU2 = pvs.XMLUnstructuredGridReader(FileName=[Input2]) VTU2.PointArrayStatus = ['Curvature'] # get active view renderView1 = pvs.GetActiveViewOrCreate('RenderView') # show data in view VTU1Display = pvs.Show(VTU1, renderView1) VTU1Display.Representation = 'Surface' VTU1Display.Diffuse = 0.85 VTU1Display.Ambient = 0.25 # show data in view VTU2Display = pvs.Show(VTU2, renderView1) VTU2Display.Representation = 'Surface' VTU2Display.Diffuse = 0.85 VTU2Display.Ambient = 0.25 # create a new 'Slice' slice1 = pvs.Slice(Input=VTU1) slice1.SliceType.Origin = Origin slice1.SliceType.Normal = N1 slice1.SliceType.Offset = 0.0 slice1.SliceOffsetValues = [Offset1] # create a new 'Slice' slice2 = pvs.Slice(Input=VTU2) slice2.SliceType.Origin = Origin slice2.SliceType.Normal = N2 slice2.SliceType.Offset = 0.0 slice2.SliceOffsetValues = [Offset2] # make stremlines makestream(VTU1, slice1, renderView1, [1.0, 0.0, 0.0]) makestream(VTU2, slice2, renderView1, [0.0, 0.0, 1.0]) # Save Screenshot AdjustCameraAndSave(renderView1, Output, ImageResolution=(2048, 2048), CamDirVec=CamDirVec, CamUpVec=CamUpVec) # set active source pvs.SetActiveSource(None) pvs.SetActiveView(None) pvs.Disconnect()
nc.GetColorRGB("Black", rgb) rgbPoints += [float(maxAmb)] + rgb # Rejected Ambiguity cLUT.RGBPoints = rgbPoints # show data in view glyph1Display = pv.Show(glyph1, renderView1) glyph1Display.ColorArrayName = ['POINTS', args.colourColumn] glyph1Display.LookupTable = cLUT if args.pcaFile: glyph1Display.Opacity = .1 # show color bar/color legend glyph1Display.SetScalarBarVisibility(renderView1, True) # set active source pv.SetActiveSource(None) cylinder1 = pv.Cylinder() # Properties modified on cylinder1 cylinder1.Resolution = 60 cylinder1.Height = tpcLength cylinder1.Radius = tpcRadius # show data in view cylinder1Display = pv.Show(cylinder1, renderView1) cylinder1Display.Orientation = [90.0, 0.0, 0.0] cylinder1Display.Opacity = 0.05 nc.GetColorRGB("White", rgb) cylinder1Display.DiffuseColor = rgb
def execute(self): self.cdms_variables = self.forceGetInputListFromPort('cdms_variable') for cdms_var in self.cdms_variables: #// Get the min and max to draw default contours min = cdms_var.var.min() max = cdms_var.var.max() reader = PVCDMSReader() time_values = [None, 1, True] image_data = reader.convert(cdms_var, time=time_values) #// Make white box filter so we can work at proxy level ProgrammableSource1 = pvsp.ProgrammableSource() #// Get a hole of the vtk level filter it controls ps = ProgrammableSource1.GetClientSideObject() #// Give it some data (ie the imagedata) ps.myid = image_data ProgrammableSource1.OutputDataSetType = 'vtkImageData' ProgrammableSource1.PythonPath = '' #// Make the scripts that it runs in pipeline RI and RD passes ProgrammableSource1.ScriptRequestInformation = """ executive = self.GetExecutive() outInfo = executive.GetOutputInformation(0) extents = self.myid.GetExtent() spacing = self.myid.GetSpacing() outInfo.Set(executive.WHOLE_EXTENT(), extents[0], extents[1], extents[2], extents[3], extents[4], extents[5]) outInfo.Set(vtk.vtkDataObject.SPACING(), spacing[0], spacing[1], spacing[2]) dataType = 10 # VTK_FLOAT numberOfComponents = 1 vtk.vtkDataObject.SetPointDataActiveScalarInfo(outInfo, dataType, numberOfComponents)""" ProgrammableSource1.Script = """self.GetOutput().ShallowCopy(self.myid)""" ProgrammableSource1.UpdatePipeline() pvsp.SetActiveSource(ProgrammableSource1) self.contour_var_name = str(cdms_var.varname) #// If the data is three dimensional, then don't draw the background imagery #// since it may hide the contours if not reader.is_three_dimensional(cdms_var): data_rep = pvsp.Show(view=self.view) data_rep.LookupTable = pvsp.GetLookupTableForArray( self.contour_var_name, 1, NanColor=[0.25, 0.0, 0.0], RGBPoints=[ min, 0.23, 0.299, 0.754, max, 0.706, 0.016, 0.15 ], VectorMode='Magnitude', ColorSpace='Diverging', LockScalarRange=1) data_rep.ColorArrayName = self.contour_var_name try: contour = pvsp.Contour() pvsp.SetActiveSource(contour) contour.ContourBy = ['POINTS', self.contour_var_name] delta = (max - min) / 10.0 contours = self.forceGetInputListFromPort("contour_values") if (len(contours) and contours): self.contour_values = [ float(d) for d in contours[0].split(',') ] # if( (self.contour_values == None) or (len(self.contour_values) == 0) ): else: self.contour_values = [(x * delta + min) for x in range(10)] functions = [] functions.append(("contour_values", [str(self.contour_values).strip('[]')])) self.update_functions('PVContourRepresentation', functions) contour.Isosurfaces = self.contour_values contour.ComputeScalars = 1 contour.ComputeNormals = 0 contour.UpdatePipeline() #// @todo: Remove hard-coded values contour_rep = pvsp.Show(view=self.view) contour_rep.Representation = 'Surface' if reader.is_three_dimensional(cdms_var): contour_rep.LookupTable = pvsp.GetLookupTableForArray( self.contour_var_name, 1, NanColor=[0.25, 0.0, 0.0], RGBPoints=[ min, 0.23, 0.299, 0.754, max, 0.706, 0.016, 0.15 ], VectorMode='Magnitude', ColorSpace='Diverging', LockScalarRange=1) contour_rep.ColorArrayName = self.contour_var_name else: contour_rep.DiffuseColor = [0.0, 0.0, 0.0] contour_rep.ColorArrayName = '' #// Scalar bar ScalarBarWidgetRepresentation1 = pvsp.CreateScalarBar( Title=self.contour_var_name, LabelFontSize=12, Enabled=1, TitleFontSize=12) self.view.Representations.append( ScalarBarWidgetRepresentation1) if not reader.is_three_dimensional(cdms_var): ScalarBarWidgetRepresentation1.LookupTable = data_rep.LookupTable else: ScalarBarWidgetRepresentation1.LookupTable = contour_rep.LookupTable except ValueError: print "[ERROR] Unable to generate contours. Please check your input values" except (RuntimeError, TypeError, NameError): print "[ERROR] Unknown error" pass
def createViews(self): """Create views """ # Disable automatic camera reset on 'Show' pv._DisableFirstRenderCameraReset() # Create render view renderView = self.createRenderView([900, 900]) # Activate render view pv.SetActiveView(renderView) # Create ExodusII reader reader = self.createExodusIIReader("Weight", "Load") # Create sqrt(load) calculator to optimize visuals sqrt_load = self.createCalculator(reader, "sqrt", "Load") # Create sqrt(load) glyph glyph = self.createGlyph(sqrt_load, factor=0.05) # Instantiate weight colors and points weight_colors = [223.48540319420192, 0.231373, 0.298039, 0.752941, 784.8585271892204, 0.865003, 0.865003, 0.865003, 1346.2316511842387, 0.705882, 0.0156863, 0.14902] weight_points = [223.48540319420192, 0.0, 0.5, 0.0, 1346.2316511842387, 1.0, 0.5, 0.0] # Create color transfert functions weightLUT = self.createColorTransferFunction( "Weight", weight_colors, [1., 1., 1.], 0.0) weightPWF = self.createOpacityTransferFunction( "Weight", weight_points) readerDisplay = self.createDisplay( reader, renderView, ['CELLS', 'Weight'], weightLUT, 4.0, None, None, weightPWF) # Instantiate load colors and points load_colors = [0.0, 0.231373, 0.298039, 0.752941, 130.73569142337513, 0.865003, 0.865003, 0.865003, 261.47138284675026, 0.705882, 0.0156863, 0.14902] load_points = [0.0, 0.0, 0.5, 0.0, 261.47138284675026, 1.0, 0.5, 0.0] # Create color transfert functions loadLUT = self.createColorTransferFunction( "Load", load_colors, [1.,1.,1.], None, "Never") loadPWF = self.createOpacityTransferFunction( "Load", load_points) # Create displays glyphDisplay = self.createDisplay( glyph, renderView, ['POINTS', 'Load'], loadLUT, None, 0.005) # Activate glyph source pv.SetActiveSource(glyph) return reader
def fitPlane(): src = smp.GetActiveSource() if not src: return selection = GetSelectionSource(src) if not selection: return extracter = smp.ExtractSelection() extracter.Selection = selection extracter.Input = src smp.Show(extracter) try: pd = extracter.GetClientSideObject().GetOutput() if pd.IsTypeOf("vtkMultiBlockDataSet"): appendFilter = vtk.vtkAppendFilter() for i in range(pd.GetNumberOfBlocks()): appendFilter.AddInputData(pd.GetBlock(i)) appendFilter.Update() pd = appendFilter.GetOutput() max_laser_id = pd.GetPointData().GetArray("laser_id").GetRange()[1] nchannels = 2**vtk.vtkMath.CeilLog2(int(max_laser_id)) origin = range(3) normal = range(3) mind, maxd, stddev = vtk.mutable(0), vtk.mutable(0), vtk.mutable(0) channelMean = range(nchannels) channelStdDev = range(nchannels) channelNpts = range(nchannels) vvmod.vtkPlaneFitter.PlaneFit(pd, origin, normal, mind, maxd, stddev, channelMean, channelStdDev, channelNpts, nchannels) rows = [[ 'overall', origin, normal, 0.0, stddev, stddev, pd.GetNumberOfPoints() ]] rows = rows + [[ '%d' % i, origin, normal, channelMean[i], channelStdDev[i], math.sqrt(channelMean[i]**2 + channelStdDev[i]**2), channelNpts[i] ] for i in range(nchannels)] def rowconverter(x): try: return '\t'.join(['%.4f' % d for d in x]) except TypeError: try: x = x.get() except AttributeError: pass if type(x) == float: return '%.4f' % x elif type(x) in (int, long): return '%d' % x else: return x print '\t'.join([ 'channel', 'originx', 'originy', 'originz', 'normalx', 'normaly', 'normalz', 'mean', 'stddev', 'RMS', 'npts' ]) for r in rows: if r[-1] == 0: r[-4:-1] = ['nan', 'nan', 'nan'] print '\t'.join([rowconverter(x) for x in r]) finally: smp.Delete(extracter) smp.SetActiveSource(src)
renderView1.CameraPosition = [1.5707999467849731, 0.5, 4.076661427044123] renderView1.CameraFocalPoint = [1.5707999467849731, 0.5, 0.7853999733924866] renderView1.CameraParallelScale = 1.8259971497854517 # save screenshot pv.SaveScreenshot('/home/avmo/test.png', renderView1, ImageResolution=[1600, 499], OverrideColorPalette='WhiteBackground') # create a new 'Contour' contour1 = pv.Contour(Input=ablnek5000) contour1.ContourBy = ['POINTS', 'velocity_mag'] contour1.Isosurfaces = [0.5744097200222313] contour1.PointMergeMethod = 'Uniform Binning' # set active source pv.SetActiveSource(contour1) # show data in view contour1Display = pv.Show(contour1, renderView1) # trace defaults for the display properties. contour1Display.Representation = 'Surface' contour1Display.ColorArrayName = ['POINTS', 'velocity_mag'] contour1Display.LookupTable = velocity_magLUT contour1Display.OSPRayScaleArray = 'velocity_mag' contour1Display.OSPRayScaleFunction = 'PiecewiseFunction' contour1Display.SelectOrientationVectors = 'None' contour1Display.ScaleFactor = 0.31415998935699463 contour1Display.SelectScaleArray = 'velocity_mag' contour1Display.GlyphType = 'Arrow' contour1Display.GlyphTableIndexArray = 'velocity_mag'
#-------------------------------------------------------------------------||---# PlotOverLine01 = Simple.PlotOverLine( guiName="PlotOverLine01", Source="High Resolution Line Source" ) PlotOverLine01.Source.Resolution = 100 PlotOverLine01.Source.Point2 = [0.00, 0.0, 20.0] PlotOverLine01.Source.Point1 = [0.00, 0.0, 0.0] # PF = Simple.ProgrammableFilter() PF.Script = Script01 Simple.Show(PF) #-------------------------------------------------------------------------||---# #-------------------------------------------------------------------------||---# Coords = Read_dat("XXX_COORDINATES.alya") for coord in Coords: print coord, Simple.SetActiveSource(InputData) Slice01 = Simple.Slice( guiName="Slice2", SliceOffsetValues=[0.0], SliceType="Plane" ) Slice01.SliceType.Origin = coord Slice01.SliceType.Normal = [0.0, 0.0, 1.0] Simple.SetActiveSource(Slice01) Calculator01 = Simple.Calculator(guiName="Calculator1", Function='VELOC_Z*TEMPE', ResultArrayName='UT') Simple.SetActiveSource(Calculator01) IntegrateVariables01 = Simple.IntegrateVariables( guiName="IntegrateVariables2" ) Simple.SetActiveSource(IntegrateVariables01) PF = Simple.ProgrammableFilter() PF.Script = Script02
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 showme(self): simple.SetActiveSource(self.proxy) self.representation.Visibility = 1
def makeStream(self): # get color transfer function/color map for the data to color with. dataLUT = simple.GetColorTransferFunction(self.plotRecipe.get('EnumColorVariable')) # create a new 'Stream Tracer' streamTracer = simple.StreamTracer(Input=self.dataObject.getData(), SeedType='High Resolution Line Source') # Properties modified on streamTracer.SeedType streamTracer.SeedType.Resolution = 450 # Properties modified on streamTracer streamTracer.MaximumSteps = 600 # show data in view streamTracerDisplay = simple.Show(streamTracer, self.dataObject.renderView) # trace defaults for the display properties. streamTracerDisplay.Representation = 'Surface' # show color bar/color legend streamTracerDisplay.SetScalarBarVisibility(self.dataObject.renderView, False) # update the view to ensure updated data information self.dataObject.renderView.Update() # create a new 'Ribbon' ribbon = simple.Ribbon(Input=streamTracer) # Properties modified on ribbon ribbon.Scalars = ['POINTS', self.plotRecipe.get('EnumColorVariable')] # show data in view ribbonDisplay = simple.Show(ribbon, self.dataObject.renderView) # trace defaults for the display properties. ribbonDisplay.Representation = 'Surface' # hide data in view simple.Hide(streamTracer, self.dataObject.renderView) # show color bar/color legend ribbonDisplay.SetScalarBarVisibility(self.dataObject.renderView, True) # update the view to ensure updated data information self.dataObject.renderView.Update() # set scalar coloring ColorBy(ribbonDisplay, ('POINTS', self.plotRecipe.get('EnumColorVariable'))) # 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 ribbonDisplay.RescaleTransferFunctionToDataRange(True, False) # show color bar/color legend ribbonDisplay.SetScalarBarVisibility(self.dataObject.renderView, True) # get color transfer function/color map for 'uds_0_scalar' colorLUT = simple.GetColorTransferFunction(self.plotRecipe.get('EnumColorVariable')) # Properties modified on ribbon ribbon.Width = 0.003 self.dataObject.renderView.ResetCamera() # update the view to ensure updated data information self.dataObject.renderView.Update() # set active source simple.SetActiveSource(streamTracer) # Properties modified on streamTracer.SeedType streamTracer.SeedType.Resolution = 200 # update the view to ensure updated data information self.dataObject.renderView.Update()