|
|
| (2 intermediate revisions by the same user not shown) |
| Line 28: |
Line 28: |
| ==Domains== | | ==Domains== |
|
| |
|
| The Server Manager provides information about values that are valid for properties. The main use of this information is for the user-interface to provide good ranges and choices in enumeration. However, some of this information is also very useful for introspection. For example, enumeration properties look like simple integer properties unless a (value, name) pair is associated with them. The Server Manager uses Domain objects to store this information. The contents of domains may be loaded from xml configuration files or computed automatically. For example:
| | {{ParaView/Template/DeprecatedUsersGuide}} |
| | |
| <source lang="python">
| |
| >>> s = Sphere()
| |
| >>> Show(s)
| |
| >>> dp = GetDisplayProperties(s)
| |
| >>> dp.Representation
| |
| 'Surface'
| |
| # The current representation type is Surface. What other types
| |
| # are available?
| |
| >>> dp.GetProperty("Representation").Available
| |
| ['Outline', 'Points', 'Wireframe', 'Surface', 'Surface With Edges']
| |
| # Choose outline
| |
| >>> dp.Representation = 'Outline'
| |
| </source>
| |
|
| |
|
| ==Source Proxies== | | ==Source Proxies== |
|
| |
|
| Source proxies are proxies that represent pipeline objects (''For more information about VTK pipelines, see the VTK books: http://vtk.org/buy-books.php''). They have special properties to connect them as well as special method to query the meta-data of their output. To connect a source proxy to another, use one of its input properties.
| | {{ParaView/Template/DeprecatedUsersGuide}} |
| | |
| <source lang="python">
| |
| # Either
| |
| >>> glyph = Glyph(elev)
| |
| # or
| |
| >>> glyph.Input = elev
| |
| </source>
| |
| | |
| The SourceProxy class provides several additional properties and methods that are specific to pipelines (See vtkSMSourceProxy documentation for a full list).
| |
| * '''UpdatePipelineInformation()''': This method calls UpdateInformation() on the VTK algorithm. It also calls UpdatePropertyInformation() to update any information properties.
| |
| * '''UpdatePipeline()''': This method calls Update() on the VTK algorithm causing a pipeline execution if the pipeline changed. Another way of causing pipeline updates is to render. The render view updates all connected pipelines.
| |
| * '''GetDataInformation()''': This method is used to obtain meta-data about one output. It is discussed further below.
| |
| * PointData and CellData properties discussed below.
| |
| | |
| There are two common ways of getting meta-data information from a proxy: information properties and DataInformation. Information properties are updated automatically every time UpdatePropertyInformation() and UpdatePipelineInformation() are called. All you have to do is read the data from the property as usual. To get a DataInformation object from a source proxy use ''GetDataInformation(port=0''). By default, this method returns data information for the first output. You can pass an optional port number to get information for another output. You can get detailed documentation on DataInformation by using help() and by reading online documentation for vtkPVDataInformation (''http://www.paraview.org/doc/nightly/html/classvtkPVDataInformation.html''). Here are the use of some common methods:
| |
| | |
| <source lang="python">
| |
| >>> di = glyph.GetDataInformation(0)
| |
| >>> di
| |
| <paraview.servermanager.DataInformation object at 0x2d0920d0>
| |
| >>> glyph.UpdatePipeline()
| |
| # Get the data type.
| |
| >>> di.GetDataClassName()
| |
| 'vtkPolyData'
| |
| # Get information about point data.
| |
| >>> pdi = glyph.PointData
| |
| # We are now directly accessing the wrapper for a VTK class
| |
| >>> len(pdi)
| |
| 2
| |
| # Get information for a point array
| |
| >>> ai = pdi[0]
| |
| >>> ai.GetRange(0)
| |
| (0.0, 0.5)
| |
| </source>
| |
| | |
| When meta-data is not enough and you need access to the raw data, you can use Fetch() to bring it to the client side. Note that this function is provided by the servermanager module. Fetch() has three modes:
| |
| | |
| *Append all of the data together and bring it to the client (only available for polygonal and unstructured datasets). Note: Do not do this if data is large otherwise the client will run out of memory.
| |
| | |
| *Bring data from a given process to the client.
| |
| | |
| *Use a reduction algorithm and bring its output to the client. For example, find the minimum value of an attribute.
| |
| | |
| Here is a demonstration:
| |
| | |
| <source lang="python">
| |
| >>> from paraview.simple import *
| |
| >>> Connect("kamino")
| |
| Connection (kamino:11111)
| |
| >>> s = Sphere()
| |
| # Get the whole sphere. DO NOT DO THIS IF THE DATA IS LARGE otherwise
| |
| # the client will run out of memory.
| |
| >>> allsphere = servermanager.Fetch(s)
| |
| getting appended
| |
| use append poly data filter
| |
| >>> allsphere.GetNumberOfPolys()
| |
| 96
| |
| # Get the piece of the sphere on process 0.
| |
| >>> onesphere = servermanager.Fetch(s, 0)
| |
| getting node 0
| |
| >>> onesphere.GetNumberOfPolys()
| |
| 48
| |
| # Apply the elevation filter so that we have a useful scalar array.
| |
| >>> elev = Elevation(s)
| |
| # We will use the MinMax algorithm to compute the minimum value of
| |
| # elevation. MinMax will be first applied on each processor. The results
| |
| # will then be gathered to the first node. MinMax will be then applied
| |
| # to the gathered results.
| |
| # We first create MinMax without an input.
| |
| >>> mm = MinMax(None)
| |
| # Set it to compute min
| |
| >>> mm.Operation = "MIN"
| |
| # Get the minimum
| |
| >>> mindata = servermanager.Fetch(elev, mm, mm)
| |
| applying operation
| |
| # The result is a vtkPolyData with one point
| |
| >>> mindata.GetPointData().GetNumberOfArrays()
| |
| 2
| |
| >>> a0 = mindata.GetPointData().GetArray(1)
| |
| >>> a0.GetName()
| |
| 'Elevation'
| |
| >>> a0.GetTuple1(0)
| |
| 0.0
| |
| </source>
| |
|
| |
|
| ==Representations and Views== | | ==Representations and Views== |
|
| |
|
| Once a pipeline is created, it can be rendered using representations and views. A view is essentially a “window” in which multiple representations can be displayed. When the view is a VTK view (such as RenderView), this corresponds to a collection of objects including vtkRenderers and a vtkRenderWindow. However, there is no requirement for a view to be a VTK view or to render anything. A representation is a collection of objects, usually a pipeline, that takes a data object, converts it to something that can be rendered, and renders it. When the view is a VTK view, this corresponds to a collection of objects including geometry filters, level-of-detail algorithms, vtkMappers and vtkActors. The simple module automatically creates a view after connecting to a server (including the built-in connection when using the stand-alone mode). Furthermore, the simple module creates a representation the first time a pipeline object is displayed with Show().
| | {{ParaView/Template/DeprecatedUsersGuide}} |
| It is easy to create new views.
| |
| | |
| <source lang="python">
| |
| >>> view = CreateRenderView()
| |
| </source>
| |
| | |
| CreateRenderView() is a special method that creates the render view appropriate for the ActiveConnection (or for another connection specified as an argument). It returns a sub-class of Proxy. Like the constructor of Proxy, it can take an arbitrary number of keyword arguments to set initial values for properties. Note that ParaView makes the view that was created last the active view. When using Show() without a view argument, the pipeline is shown in the active view. You can get a list of views as well as the active view as follows:
| |
| | |
| <source lang="python">
| |
| >>> GetRenderViews()
| |
| [<paraview.servermanager.RenderView object at 0xaf64ef0>, <paraview.servermanager.RenderView object at 0xaf64b70>]
| |
| >>> GetActiveView()
| |
| <paraview.servermanager.RenderView object at 0xaf64b70>
| |
| </source>
| |
| | |
| You can also change the active view using SetActiveView().
| |
| | |
| Once you have a render view, you can use pass it to Show in order to select in which view a pipeline object is displayed. You can also pass it to Render() to select which view is rendered.
| |
| | |
| <source lang="python">
| |
| >>> Show(elev, GetRenderViews()[1])
| |
| <paraview.servermanager.GeometryRepresentation object at 0xaf64e30>
| |
| >>> Render(GetRenderViews()[1])
| |
| </source>
| |
| | |
| Notice that Show() returns a representation object (aka DisplayProperties in the simple module). This object can be used to manipulate how the pipeline object is displayed in the view. You can also access the display properties of an object using GetDisplayProperties().
| |
| | |
| <source lang="python">
| |
| >>> dp = GetDisplayProperties(elev)
| |
| >>> dp
| |
| <paraview.servermanager.GeometryRepresentation object at 0xaf649d0>
| |
| </source>
| |
| | |
| Display properties and views have a large number of properties some of which are poorly documented. We will cover some them here.
| |
| | |
| <source lang="python">
| |
| >>> from paraview.simple import *
| |
| # Create a simple pipeline
| |
| >>> sph = Sphere()
| |
| >>> elev = Elevation(sph)
| |
| >>> Show(elev)
| |
| >>> Render()
| |
| # Set the representation type of elev
| |
| >>> dp = GetDisplayProperties(elev)
| |
| >>> dp.Representation = 'Points'
| |
| # Here is how you get the list of representation types
| |
| >>> dp.GetProperty("Representation").Available
| |
| ['Outline', 'Points', 'Wireframe', 'Surface', 'Surface With Edges']
| |
| >>> Render()
| |
| # Change the representation to wireframe
| |
| >>> dp.Representation = 'Wireframe'
| |
| >>> Render()
| |
| # Let’s get some information about the output of the elevation
| |
| # filter. We want to color the representation by one of it’s
| |
| # arrays.
| |
| # Second array = Elevation. Interesting. Let’s use this one.
| |
| >>> ai = elev.PointData[1]
| |
| >>> ai.GetName()
| |
| 'Elevation'
| |
| # What is its range?
| |
| >>> ai.GetRange()
| |
| (0.0, 0.5)
| |
| # To color the representation by an array, we need to first create
| |
| # a lookup table. We use the range of the Elevation array
| |
| >>> dp.LookupTable = MakeBlueToRedLT(0, 0.5)
| |
| >>> dp.ColorAttributeType = 'POINT_DATA'
| |
| >>> dp.ColorArrayName = 'Elevation' # color by Elevation
| |
| >>> Render()
| |
| </source>
| |
| | |
| Here is the result:
| |
| [[Image:SMView.png|thumb|center|800px|'''Figure 14.2''' Object displayed in a view]]
| |
| | |
| | |
| Once you create a scene, you will probably want to interact with the camera and ResetCamera() is likely to be insufficient. In this case, you can directly get the camera from the view and manipulate it. GetActiveCamera() returns a VTK object (not a proxy) with which you can interact.
| |
| | |
| <source lang="python">
| |
| >>> camera = GetActiveCamera()
| |
| >>> camera
| |
| <libvtkCommonPython.vtkCamera vtkobject at 0xe290>
| |
| >>> camera.Elevation(45)
| |
| >>> Render()
| |
| </source>
| |
| | |
| Another common thing to do is to save the view as an image. For this purpose, you can use the WriteImage() method provided by the view:
| |
| | |
| <source lang="python">
| |
| >> WriteImage("/Users/berk/image.png")
| |
| </source>
| |
| | |
| The resulting image.png looks like this. See the documentation for WriteImage() for details on choosing file type, as well as a magnification factor to save images larger than the view size.
| |
| | |
| [[Image:Image.jpg|thumb|center|800px|'''Figure 14.3''' Saving a view as an image]]
| |
|
| |
|
| =Advanced Concepts= | | =Advanced Concepts= |
