simple Package

simple Package

simple is a module for using paraview server manager in Python. It provides a simple convenience layer to functionality provided by the C++ classes wrapped to Python as well as the servermanager module.

A simple example:

from paraview.simple import *

# Create a new sphere proxy on the active connection and register it
# in the sources group.
sphere = Sphere(ThetaResolution=16, PhiResolution=32)

# Apply a shrink filter
shrink = Shrink(sphere)

# Turn the visibility of the shrink object on.
Show(shrink)

# Render the scene
Render()

Scripts generated by ParaView’s Python Tracing, Python state saving, and Catalyst saving use functions in this module.

paraview.simple.AMRConnectivity(*input, **params)

paraview.simple.AMRContour(*input, **params)

paraview.simple.AMRDualClip(*input, **params)

paraview.simple.AMRFragmentIntegration(*input, **params)

paraview.simple.AMRFragmentsFilter(*input, **params)

Combines the running of

AMRContour, AMRFragmentIntegration, AMRDualContour and ExtractCTHParts

paraview.simple.AMRGaussianPulseSource(*input, **params)

AMR

dataset source, used for generating sample Berger-Collela AMR dataset with a Gaussian Pulse field at the center.

paraview.simple.AMReXBoxLibGridReader(*input, **params)

This AMReX reader loads data stored in AMReX plt file format. The output of this reader is a hierarchical-box dataset.

paraview.simple.AMReXBoxLibParticlesReader(*input, **params)

Reads particle data from AMReX plotfiles. This is a distributed reader.

paraview.simple.AVSUCDReader(*input, **params)

The AVS UCD

reader reads binary or ASCII files stored in AVS UCD format. The default file extension is .inp. The output of this reader is unstructured grid. This supports reading a file series.

paraview.simple.AdaptiveResampleToImage(*input, **params)

paraview.simple.AddCameraLink(viewProxy, viewProxyOther, linkName='')

Create a named camera link between two view proxies. If a link with the given name already exists it will be removed first and replaced with the newly created link.

Parameters

• viewProxy (View proxy.) – The first view to link.

• viewProxyOther (View proxy.) – The second view to link.

• linkName (str) – The name of the link to create. Optional, defaults to automatically generating a link name.

Returns

The link registration name.

Return type

str

paraview.simple.AddFieldArrays(*input, **params)

AddFieldArrays is a deprecated proxy. It will be automatically replaced by FieldArraysFromFile

paraview.simple.AddLight(view=None)

Makes a new light and adds it to the designated or active view.

Parameters

view – The view to add the light to. Optional, defaults to the active view.

Returns

The new light

Return type

paraview.servermanager.Light

paraview.simple.AddProxyLink(proxy1, proxy2, linkName='', link=None)

Create a link between two proxies and return its name.

An instance of a vtkSMProxyLink subclass can be given, otherwise a vtkSMProxyLink is created. This does not link proxy properties. See vtkSMProxyLink.LinkProxyPropertyProxies.

Parameters

linkName (str) – Name of link to create. If empty, a default one is created for registration. If a link with the given name already exists it will be removed first.

Returns

The link registration name.

Return type

str

paraview.simple.AddRenderViewLink(viewProxy, viewProxyOther, linkName='', linkCameras=False)

Create a named view link between two render view proxies.

It also creates links for the AxesGrid proxy property in each view. By default, cameras are not linked.

If a link with the given name already exists it will be removed first and replaced with the newly created link.

Parameters

• viewProxy (View proxy.) – The first view to link.

• viewProxyOther (View proxy.) – The second view to link.

• linkName (str) – The name of the link to create.

• linkCameras – If True, also link the view cameras.

Returns

The link registration name.

Return type

str

paraview.simple.AddSelectionLink(objProxy, objProxyOther, linkName, convertToIndices=True)

Create a named selection link between two source proxies. If a link with the given name already exists it will be removed first and repaced with the newly created link.

Parameters

• objProxy (Source proxy) – First proxy to link.

• objProxyOther (Source proxy) – Second proxy to link. If None, uses the active source.

• linkName (str) – Name of the created link.

• convertToIndices (bool) – When True (default value), the input selection will always be converted into an indices-based selection before being applied to outputs.

paraview.simple.AddViewLink(viewProxy, viewProxyOther, linkName='')

Create a view link between two view proxies.

A view link is an extension of a proxy link that also performs rendering when a property changes.

Cameras in the views are not linked.

If a link with the given name already exists it will be removed first and replaced with the newly created link.

Parameters

• viewProxy (View proxy.) – The first view to link.

• viewProxyOther (View proxy.) – The second view to link.

• linkName (str) – The name of the link to create. Optional, defaults to automatically generating a link name.

Returns

The link registration name.

Return type

str

paraview.simple.AggregateDataset(*input, **params)

This filter aggregates a dataset onto a subset of processes.

paraview.simple.AlignImageOrigins(*input, **params)

The Align Image Origins filter treats input images as parts of a whole, and sets the same origin. Each block’s extent is set relative to that origin.

paraview.simple.AngularPeriodicFilter(*input, **params)

This filter generate a periodic multiblock dataset

paraview.simple.AnimateModes(*input, **params)

For certain file formats, like Exodus, simulation codes may use the timesteps and time values to represent quantities other than time. For example, for modal analysis, the natural frequency for each mode may be used as the time value. Animate Modes can be used to reinterpret time as mode shapes. The filter can also animate vibrations for each mode shape (when AnimateVibrations is set to true). In that case, the time requested by the downstream pipeline is used to scale the displacement magnitude for a mode shape in a sinusoidal pattern, cos(2*pi * requested-time).

paraview.simple.AnimateReader(reader=None, view=None)

This is a utility function that, given a reader and a view animates over all time steps of the reader.

Parameters

• reader (reader proxy) – The reader source to iterate over. Optional, defaults to the active source.

• view (view proxy) – The view to animate. Optional, defaults to the active view.

Returns

A new animation scene used to play the animation.

Return type

paraview.simple.AnimationSceneProxy

paraview.simple.AnimationCueBase(*input, **params)

Internal base interface for all animation

cues.

paraview.simple.AnimationScene(*input, **params)

Proxy for animation scene.

paraview.simple.AnnotateAttributeData(*input, **params)

This filter can be used to add a text annotation to a Render View (or similar) using a tuple from any attribute array (point/cell/field/row etc.) from a specific rank (when running in parallel). Use ArrayName property to select the array association and array name. Use ElementId* property to set the element number to extract the value to label with. When running on multiple ranks, use **ProcessId property to select the rank of interest. The Prefix property can be used to specify a string that will be used as the prefix to the generated annotation text.

paraview.simple.AnnotateGlobalData(*input, **params)

Generates annotation text from global / field data presumed to be associated with time steps in the source dataset for this filter. If the field array chosen has as many elements as number of timesteps, the array is assumed to be “temporal” and indexed using the current timestep.

paraview.simple.AnnotateSelection(*input, **params)

Generates annotation text for each selectionNode from a selection.

paraview.simple.AnnotateTime(*input, **params)

The Annotate Time

source can be used to show the animation time in text annotation.

paraview.simple.AnnotateTimeFilter(*input, **params)

The Annotate Time

filter can be used to show the data time in a text annotation.

paraview.simple.AppendArcLength(*input, **params)

AppendArcLength is a deprecated proxy. It will be automatically replaced by PolylineLength

paraview.simple.AppendAttributes(*input, **params)

The Append Attributes filter takes multiple input data sets with the same geometry and merges their point and cell attributes to produce a single output containing all the point and cell attributes of the inputs. Any inputs without the same number of points and cells as the first input are ignored. The input data sets must already be collected together, either as a result of a reader that loads multiple parts (e.g., EnSight reader) or because the Group Parts filter has been run to form a collection of data sets.

paraview.simple.AppendDatasets(*input, **params)

The Append

Datasets filter operates on multiple data sets of any type (polygonal, structured, etc.). It merges their meshes into a single dataset. If all inputs are polydata, the output is a polydata, otherwise it is an unstructured grid. Only the point and cell attributes that all of the input datasets have in common will appear in the output.

paraview.simple.AppendGeometry(*input, **params)

The Append

Geometry filter operates on multiple polygonal data sets. It merges their geometry into a single data set. Only the point and cell attributes that all of the input data sets have in common will appear in the output.

paraview.simple.AppendLocationAttributes(*input, **params)

AppendLocationAttributes is a deprecated proxy. It will be automatically replaced by Coordinates

paraview.simple.AppendMolecule(*input, **params)

Appends one or more molecules into a single molecule. It also appends the associated atom data and edge data. Note that input data arrays should match (same number of arrays with same names in each input)

paraview.simple.AppendReduce(*input, **params)

paraview.simple.AppendSelections(*input, **params)

Append multiple selections with one or many nodes, with the same fieldType, and possibly different content type, to create a combined selection. Each selection has a name and a boolean expression can be set using the selection names to define the relation between the selections.

paraview.simple.Arrow(*input, **params)

The Arrow source appends a

cylinder to a cone to form a 3D arrow. The length of the whole arrow is 1.0 unit. The output of the Arrow source is polygonal data. This polygonal data will not contain normals, so rendering of the arrow will be performed using flat shading. The appearance of the arrow can be improved without significantly increasing the resolution of the tip and shaft by generating normals. (Use Normals Generation filter).

paraview.simple.AssignFieldToColorPreset(array_name, preset_name, range_override=None)

Assign a lookup table to an array by lookup table name.

Example usage:

AssignFieldToPreset("Temperature", "Cool to Warm")

Parameters

• array_name (str) – The array name for which we want to bind a given color preset.

• preset_name (str) – The name for the color preset.

• range_override (2-element tuple or list of floats) – The range to use instead of the range of the array.

Returns

True on success, False otherwise.

Return type

bool

paraview.simple.AssignLookupTable(arrayInfo, lutName, rangeOveride=[])

Assign a lookup table to an array by lookup table name.

Example usage:

track = GetAnimationTrack("Center", 0, sphere) or
arrayInfo = source.PointData["Temperature"]
AssignLookupTable(arrayInfo, "Cool to Warm")

Parameters

• arrayInfo (paraview.modules.vtkRemotingCore.vtkPVArrayInformation) – The information object for the array. The array name and its range is determined using the info object provided.

• lutName (str) – The name for the transfer function preset.

• rangeOveride (2-element tuple or list of floats) – The range to use instead of the range of the array determined using the arrayInfo parameter. Defaults to [], meaning the array info range will be used.

Returns

True on success, False otherwise.

Return type

bool

paraview.simple.AssignViewToLayout(view=None, layout=None, hint=0)

Assigns the view provided to the layout provided. If no layout exists, then a new layout will be created.

It is an error to assign the same view to multiple layouts.

Parameters

• view (View proxy.) – The view to assign to the layout. Optional, defaults to the active view.

• layout (Layout proxy.) – If layout is None, then either the active layout or an existing layout on the same server will be used.

Returns

Returns True on success.

Return type

bool

paraview.simple.Axes(*input, **params)

The Axes source can be used to add a representation of the coordinate system axes to the 3D scene. The X axis will be drawn as a blue line, the Y axis as a green line, and the Z axis as a red line. The axes can be drawn either as three lines drawn in the positive direction from the origin or as three lines crossing at the origin (drawn in both the positive and negative directions). The output of the Axes source is polygonal data. This polygonal data has a scalar per line so that the lines can be colored. It also has normals defined.

paraview.simple.AxisAlignedReflectionFilter(*input, **params)

The Axis Aligned Reflection filter reflects the input dataset across the specified plane. This filter operates on any type of data set or hyper tree grid and produces a Partitioned DataSet Collection containing partitions of the same type as the input (the reflection and the input if CopyInput is enabled).

paraview.simple.AxisAlignedSlice(*input, **params)

This filter produces axis-aligned slices of the input HyperTree Grids and Overlapping AMRs. The output data type is the same as the input, effectively reducing the dimensionality of the input by one. In the case of HyperTree Grids, multiple slices can be produced at once. All output slices are stored in a Partitioned Dataset Collection of HyperTree Grids.

paraview.simple.BDFReader(*input, **params)

This reads data from

Nastran Bulk Data File format. It supports only the “free field format” and a subset of “Entries”.

paraview.simple.BYUReader(*input, **params)

The BYU reader reads

data stored in Movie.BYU format. The expected file extension is .g. The datasets resulting from reading these files are polygonal.

paraview.simple.BlockIds(*input, **params)

The Level

Scalars filter uses colors to show levels of a multiblock dataset.

paraview.simple.BlockScalars(*input, **params)

BlockScalars is a deprecated proxy. It will be automatically replaced by BlockIds

paraview.simple.BlockSelectionSource(*input, **params)

BlockSelectionSource is a source producing a block-based selection used to select blocks from a composite dataset.

paraview.simple.BlockSelectorsSelectionSource(*input, **params)

BlockSelectorsSelectionSource is a source producing a block-based selection used to select blocks from a composite dataset using selectors.

paraview.simple.BooleanKeyFrame(*input, **params)

paraview.simple.BoundaryMeshQuality(*input, **params)

This filter computes metrics on the boundary faces of a volumetric mesh. The metrics that can be computed on the boundary faces of the mesh and are: (1) Distance from cell center to face center (2) Distance from cell center to face’s plane (3) Angle of face’s plane normal and cell center to face center vector

paraview.simple.BoundingRuler(*input, **params)

This filter creates a line along the object and defaults its representation to showing a ruler along that line.

paraview.simple.Box(*input, **params)

The

Box source can be used to add a box to the 3D scene. The output of the Box source is polygonal data containing both normals and texture coordinates.

paraview.simple.CGNSSeriesReader(*input, **params)

The CGNS reader reads binary files stored in CGNS format. The default file extension is .cgns. The output of this reader is a multi-block dataset. This is a distributed reader. This reader also supports file series.

paraview.simple.CGNSWriter(*input, **params)

The CGNS writer writes files stored in CGNS format. The file extension is .cgns. The input of this reader is a structured grid, polygon data, unstructured grid or a multi-block dataset containing these data types.

paraview.simple.CMLMoleculeReader(*input, **params)

This is a reader for Chemical Markup Language (CML) which describes chemical information using XML.

paraview.simple.CONVERGECFDCGNSReader(*input, **params)

This reader reads CONVERGECFD post files using the CGNS standard (.cgns extension). Meshes, surfaces, and parcels are read. Parcels are defined inside “PARCEL_DATA” UserDefinedData_t nodes.

paraview.simple.CONVERGECFDReader(*input, **params)

Reads CONVERGE post files containing meshes, surfaces, and parcels into a multiblock dataset. Each stream in a file is read as a top-level block and meshes, surfaces, and parcels are datasets under each stream.

paraview.simple.CSVReader(*input, **params)

The CSV

reader reads a Delimited Text values file into a 1D rectilinear grid. If the file was saved using the CSVWriter, then the rectilinear grid’s points and point data can be restored as well as the cell data. Otherwise all the data in the CSV file is treated as cell data. The default file extension is .csv as well as .txt. This can read file series as well.

paraview.simple.CSVWriter(*input, **params)

Writer to write comma or tab delimited files from any dataset. Set FieldAssociation to choose whether cell data/point data needs to be saved. If the file extension is tsv it uses the tab character for the delimiter. Otherwise, it uses a comma.

paraview.simple.Calculator(*input, **params)

The Calculator filter computes a new data array or new point coordinates as a function of existing scalar or vector arrays. If point-centered arrays are used in the computation of a new data array, the resulting array will also be point-centered. Similarly, computations using cell-centered arrays will produce a new cell-centered array. If the function is computing point coordinates, the result of the function must be a three-component vector.

The Calculator interface operates similarly to a scientific calculator. In creating the function to evaluate, the standard order of operations applies. Each of the calculator functions is described below. Unless otherwise noted, enclose the operand in parentheses using the ( and ) buttons.

• Clear: Erase the current function (displayed in the read-only text box above the calculator buttons).

• /: Divide one scalar by another. The operands for this function are not required to be enclosed in parentheses.

• *: Multiply two scalars, or multiply a vector by a scalar (scalar multiple). The operands for this function are not required to be enclosed in parentheses.

• -: Negate a scalar or vector (unary minus), or subtract one scalar or vector from another. The operands for this function are not required to be enclosed in parentheses.

• +: Add two scalars or two vectors. The operands for this function are not required to be enclosed in parentheses.

• sin: Compute the sine of a scalar.

• cos: Compute the cosine of a scalar.

• tan: Compute the tangent of a scalar.

• asin: Compute the arcsine of a scalar.

• acos: Compute the arccosine of a scalar.

• atan: Compute the arctangent of a scalar.

• sinh: Compute the hyperbolic sine of a scalar.

• cosh: Compute the hyperbolic cosine of a scalar.

• tanh: Compute the hyperbolic tangent of a scalar.

• min: Compute minimum of two scalars.

• max: Compute maximum of two scalars.

• x^y: Raise one scalar to the power of another scalar. The operands for this function are not required to be enclosed in parentheses.

• sqrt: Compute the square root of a scalar.

• exp: Raise e to the power of a scalar.

• ln: Compute the logarithm of a scalar to the base ‘e’.

• log10: Compute the logarithm of a scalar to the base 10.

• ceil: Compute the ceiling of a scalar. floor: Compute the floor of a scalar.

• abs: Compute the absolute value of a scalar.

• dot: Compute the dot product of two vectors.

• cross: Compute cross product of two vectors.

• mag: Compute the magnitude of a vector.

• norm: Normalize a vector.

The operands are described below. The digits 0 - 9 and the decimal point are used to enter constant scalar values. iHat, jHat, and kHat are vector constants representing unit vectors in the X, Y, and Z directions, respectively. The scalars menu lists the names of the scalar arrays and the components of the vector arrays of either the point-centered or cell-centered data. The vectors menu lists the names of the point-centered or cell-centered vector arrays. The function will be computed for each point (or cell) using the scalar or vector value of the array at that point (or cell). The filter operates on any type of data set, but the input data set must have at least one scalar or vector array. The arrays can be either point-centered or cell-centered. The Calculator filter’s output is of the same data set type as the input.

The output array type can be specified as an advanced option with the default being of a vtkDoubleArray.

paraview.simple.CameraAnimationCue(*input, **params)

Animation cue which can be used for animating Camera using

keyframes.

paraview.simple.CameraKeyFrame(*input, **params)

paraview.simple.CellCenters(*input, **params)

The Cell Centers

filter places a point at the center of each cell in the input dataset. The center computed is the parametric center of the cell, not necessarily the geometric or bounding box center. The cell attributes of the input will be associated with these newly created points of the output. You have the option of creating a vertex cell per point in the output. This is useful because vertex cells are rendered, but points are not. The points themselves could be used for placing glyphs (using the Glyph filter). The Cell Centers filter takes any type of dataset or a HyperTree Grid as input and produces a polygonal dataset as output.

paraview.simple.CellDatatoPointData(*input, **params)

The Cell Data to Point Data filter averages the values of the cell attributes of the cells surrounding a point to compute point attributes. The Cell Data to Point Data filter operates on any type of data set, and the output data set is of the same type as the input.

paraview.simple.CellGridCenters(*input, **params)

This filter adds a vertex cell at the center of each input cell. The output will have all of the attributes defined on the cell interpolated to the output vertices.

paraview.simple.CellGridElevation(*input, **params)

This filter adds a cell-attribute named Elevation that represents the distance from either (1) a point, (2) a line, or (3) a plane.

paraview.simple.CellGridProbe(*input, **params)

This filter copies the input polydata and adds information about how its points are related to cells of an input cell grid.

paraview.simple.CellGridSource(*input, **params)

This source creates a cell grid populated with a single cell of the specified type. If the cell’s type uses a reference-element formulation, the cell should have an identity map from reference space to world-coordinates space.

paraview.simple.CellGridToUnstructuredGrid(*input, **params)

This filter approximates a cell grid with an unstructured grid whose cells are linear approximations to cells in the cell grid. All higher-order information is discarded. All fields on the cell grid are converted into point-data on the unstructured grid; since points are shared by neighboring cells, the values at points are averaged across all cells incident to the point. Thus discontinuities at cell boundaries are eliminated by averaging.

paraview.simple.CellGridTransform(*input, **params)

This filter allows you to translate, rotate, and scale cell-grid data.

paraview.simple.CellGridWarp(*input, **params)

This filter allows you to deform a cell grid. Responders currently require interpolation schemes for the shape and deformation attribute to match.

paraview.simple.CellQuality(*input, **params)

This filter creates a new cell array containing a geometric measure of each cell’s shape. It supports more shapes than Mesh Quality such as pixels and triangle stripes. It has few differences with MeshQuality: it computes the same metric for all type of cell and provides an API to specify unsupported value for unsupported metric or cell type.

paraview.simple.CellSize(*input, **params)

This filter computes sizes for 0D (1 for vertex and number of points in for polyvertex), 1D (length), 2D (area)

and 3D (volume) cells. ComputeVertexCount, ComputeLength, ComputeArea and ComputeVolume options can be used to specify what dimension cells to compute for. The values are placed in a cell data array named ArrayName. The ComputeSum option will give a summation of the computed cell sizes for a vtkDataSet and for composite datasets will contain a sum of the underlying blocks in the top-level block.

paraview.simple.CityGMLReader(*input, **params)

vtkCityGMLReader is a reader for CityGML .gml files. The output is a multiblock dataset. We read objects at level of detail (LOD) specified (default is 3). The leaves of the multiblock dataset (which are polygonal datasets) have a field array with one element called “gml_id” which corresponds to the gml:id for gml:TriangulatedSurface, gml:MultiSurface or gml:CompositeSurface in the CityGML file. If the polygonal dataset has a texture, we specify this with a point array called “tcoords” and a field array with one element called “texture_uri” containing the path to the texture file. Top level children of the multiblock dataset have a field array with one element called “element” which contains the CityGML element name for example: dem:ReliefFeature, wtr:WaterBody, grp::CityObjectGroup (forest), veg:SolitaryVegetationObject, brid:Bridge, run:Tunel, tran:Railway, tran:Road, bldg:Building, gen:GenericCityObject, luse:LandUse

paraview.simple.Clean(*input, **params)

The Clean filter

takes polygonal data as input and generates polygonal data as output. This filter can merge duplicate points, remove unused points, and transform degenerate cells into their appropriate forms (e.g., a triangle is converted into a line if two of its points are merged).

paraview.simple.CleanCellstoGrid(*input, **params)

Merges degenerate cells. Assumes

the input grid does not contain duplicate points. You may want to run vtkCleanUnstructuredGrid first to assert it. If duplicated cells are found they are removed in the output. The filter also handles the case, where a cell may contain degenerate nodes (i.e. one and the same node is referenced by a cell more than once).

paraview.simple.CleantoGrid(*input, **params)

The Clean to Grid filter merges

points that are exactly coincident. It also converts the data set to an unstructured grid. You may wish to do this if you want to apply a filter to your data set that is available for unstructured grids but not for the initial type of your data set (e.g., applying warp vector to volumetric data). The Clean to Grid filter operates on any type of data set.

paraview.simple.ClearSelection(proxy=None)

Clears the selection on the active source.

Parameters

proxy (Source proxy) – Source proxy whose selection should be cleared.

paraview.simple.ClientServerMoveData(*input, **params)

paraview.simple.Clip(*input, **params)

The Clip filter

cuts away a portion of the input data set using an implicit function (an implicit description). This filter operates on all types of data sets, and it returns unstructured grid data on output.

paraview.simple.ClipClosedSurface(*input, **params)

This clip filter cuts away a portion of the input polygonal dataset using a plane to generate a new polygonal dataset.

paraview.simple.ClipGenericDataset(*input, **params)

The Generic Clip filter cuts away a portion of the input data set using a plane, a sphere, a box, or a scalar value. The menu in the Clip Function portion of the interface allows the user to select which implicit function to use or whether to clip using a scalar value. Making this selection loads the appropriate user interface. For the implicit functions, the appropriate 3D widget (plane, sphere, or box) is also displayed. The use of these 3D widgets, including their user interface components, is discussed in section 7.4. If an implicit function is selected, the clip filter returns that portion of the input data set that lies inside the function. If Scalars is selected, then the user must specify a scalar array to clip according to. The clip filter will return the portions of the data set whose value in the selected Scalars array is larger than the Clip value. Regardless of the selection from the Clip Function menu, if the Inside Out option is checked, the opposite portions of the data set will be returned. This filter operates on all types of data sets, and it returns unstructured grid data on output.

paraview.simple.ColorBlocksBy(rep=None, selectors=None, value=None, separate=False)

Like ColorBy(), set data array by which to color selected blocks within a representation, but color only selected blocks with the specified properties. This will automatically set up the color maps and others necessary state for the representations.

Parameters

• rep (Representation proxy) – Must be a representation proxy i.e. the value returned by the GetRepresentation(). Optional, defaults to the display properties for the active source, if possible.

• selectors (list of str) – List of block selectors that choose which blocks to modify with this call.

• value (str) – Name of the array to color by.

• separate (bool) – Set to True to create a color map unique to this representation. Optional, default is that the color map used will be the global color map ParaView uses for any object colored by an array of the same name.

paraview.simple.ColorBy(rep=None, value=None, separate=False)

Set data array to color a representation by. This will automatically set up the color maps and others necessary state for the representations.

Parameters

• rep (Representation proxy) – Must be a representation proxy i.e. the value returned by the GetRepresentation(). Optional, defaults to the display properties for the active source, if possible.

• value (str) – Name of the array to color by.

• separate (bool) – Set to True to create a color map unique to this representation. Optional, defaults to the global color map ParaView uses for any object colored by an array of the same name.

paraview.simple.ColorByArray(*input, **params)

paraview.simple.ComparativeAnimationCue(*input, **params)

Animation cue used by comparative views.

paraview.simple.CompositeCellGridReader(*input, **params)

Reader for discontinuous Galerkin and other data in cell-grid format. This is a distributed reader.

paraview.simple.CompositeDataIDSelectionSource(*input, **params)

CompositeDataIDSelectionSource used to create an ID based selection for composite datasets (Multiblock or HierarchicalBox dataset).

paraview.simple.CompositeKeyFrame(*input, **params)

paraview.simple.ComputeConnectedSurfaceProperties(*input, **params)

ComputeConnectedSurfaceProperties is a deprecated proxy. It will be automatically replaced by ConnectedSurfaceProperties

paraview.simple.ComputeDerivatives(*input, **params)

Cell Derivatives is a filter that computes derivatives of scalars and vectors at the center of cells. You can choose to generate different output including the scalar gradient (a vector), computed tensor vorticity (a vector), gradient of input vectors (a tensor), and strain matrix of the input vectors (a tensor); or you may choose to pass data through to the output.

paraview.simple.ComputeMoleculeBonds(*input, **params)

Compute the bonds of a molecule. If the interatomic distance is less than the sum of the two atom’s covalent radii (and a tolerance), a single bond is added. This algorithm does not consider valences, hybridization, aromaticity, or anything other than atomic separations. It will not produce anything other than single bonds.

paraview.simple.ComputeQuartiles(*input, **params)

paraview.simple.ComputeSides(*input, **params)

This filter adds arrays (if not already present) holding tuples of (cell ID, side ID) pairs which identify the sides of all the cells which do not share a boundary with a neighbor (i.e., any external surfaces as well as non-conforming internal surfaces). These arrays are grouped by the type of cells whose sides they refer to as well as the shape of the side. (For example, a group of wedge cells will have one array listing quadrilateral sides and another array listing triangular sides.) These arrays can be used to render the cell grid efficiently.

paraview.simple.Conduit(*input, **params)

A data source that takes a Conduit node using the Mesh Blueprint to produce data.

paraview.simple.Cone(*input, **params)

The Cone

source can be used to add a polygonal cone to the 3D scene. The output of the Cone source is polygonal data.

paraview.simple.Connect(ds_host=None, ds_port=11111, rs_host=None, rs_port=11111, timeout=60, ns=None)

Creates a connection to a server.

Parameters

• ds_host (string) – Data server hostname. Needed to set up a client/data server/render server connection.

• ds_port (int) – Data server port to listen on.

• rs_host (string) – Render server hostname. Needed to set up a client/data server/render server connection.

• rs_port (int) – Render server port to listen on.

• timeout (int) – Time in seconds at which the connection is abandoned if not made.

Example usage connecting to a host named “amber”:

Connect("amber") # Connect to a single server at default port
Connect("amber", 12345) # Connect to a single server at port 12345
Connect("amber", 11111, "vis_cluster", 11111) # connect to data server, render server pair
Connect("amber", timeout=30) # Connect to a single server at default port with a 30s timeout instead of default 60s
Connect("amber", timeout=-1) # Connect to a single server at default port with no timeout instead of default 60s
Connect("amber", timeout=0)  # Connect to a single server at default port without retrying instead of retrying for
the default 60s

paraview.simple.ConnectedSurfaceProperties(*input, **params)

Given a PolyData, computed the volume, area and centroid of one or more polygonal objects. An optional object IDs cell data array that maps a polygon to a specific object may be provided, or the objects will be identified as connected components in the input data.

paraview.simple.Connectivity(*input, **params)

The Connectivity

filter assigns a region id to connected components of the input data set. (The region id is assigned as a point scalar value.) This filter takes any data set type as input and produces unstructured grid output.

paraview.simple.ContingencyStatistics(*input, **params)

This filter either computes a statistical model of a dataset or takes such a model as its second input. Then, the model (however it is obtained) may optionally be used to assess the input dataset. This filter computes contingency tables between pairs of attributes. This result is a tabular bivariate probability distribution which serves as a Bayesian-style prior model. Data is assessed by computing <ul> <li> the probability of observing both variables simultaneously; <li> the probability of each variable conditioned on the other (the two values need not be identical); and <li> the pointwise mutual information (PMI). </ul> Finally, the summary statistics include the information entropy of the observations.

paraview.simple.Contour(*input, **params)

The Contour

filter computes isolines or isosurfaces using a selected point-centered scalar array. The Contour filter operates on any type of data set, but the input is required to have at least one point-centered scalar (single-component) array. The output of this filter is polygonal.

paraview.simple.ContourGenericDataset(*input, **params)

The Generic

Contour filter computes isolines or isosurfaces using a selected point-centered scalar array. The available scalar arrays are listed in the Scalars menu. The scalar range of the selected array will be displayed. The interface for adding contour values is very similar to the one for selecting cut offsets (in the Cut filter). To add a single contour value, select the value from the New Value slider in the Add value portion of the interface and click the Add button, or press Enter. To instead add several evenly spaced contours, use the controls in the Generate range of values section. Select the number of contour values to generate using the Number of Values slider. The Range slider controls the interval in which to generate the contour values. Once the number of values and range have been selected, click the Generate button. The new values will be added to the Contour Values list. To delete a value from the Contour Values list, select the value and click the Delete button. (If no value is selected, the last value in the list will be removed.) Clicking the Delete All button removes all the values in the list. If no values are in the Contour Values list when Accept is pressed, the current value of the New Value slider will be used. In addition to selecting contour values, you can also select additional computations to perform. If any of Compute Normals, Compute Gradients, or Compute Scalars is selected, the appropriate computation will be performed, and a corresponding point-centered array will be added to the output. The Generic Contour filter operates on a generic data set, but the input is required to have at least one point-centered scalar (single-component) array. The output of this filter is polygonal.

paraview.simple.ConvertAMRdatasettoMultiblock(*input, **params)

paraview.simple.ConvertIntoMolecule(*input, **params)

Convert a point set into a molecule. Every point of the input becomes an atom of the output molecule. It needs a point array containing the atomic numbers.

paraview.simple.ConvertPolyhedralCells(*input, **params)

Attempt to convert polyhedral cells to simple cells (tetrahedron, pyramid, wedge or hexahedron). It will speed up downstream processing if polyhedral cells can be treated as simple cells.

paraview.simple.ConvertSelection(*input, **params)

Converts a selection from one type to another.

paraview.simple.ConvertToCellGrid(*input, **params)

This filter turns an unstructured grid or partitioned dataset collection whose leaf nodes are unstructured grids with linear cells into a partitioned dataset collection of cell grids.

Additionally, it uses annotations added to the field data by the IOSS reader to promote certain cell-data arrays into spatially-varying discontinuous Galerkin attributes.

Note that even unstructured grids with no annotations are converted into cell grids so that the entire dataset can be rendered using the composite cell-grid representation.

paraview.simple.ConvertToMultiBlock(*input, **params)

Convert any dataset to vtkMultiBlockDataSet.

paraview.simple.ConvertToPartitionedDataSetCollection(*input, **params)

Convert any dataset to vtkPartitionedDataSetCollection.

paraview.simple.ConvertToPointCloud(*input, **params)

The ConvertToPointCloud convert any dataset to a vtkPolyData containing the points and point data of the input and generate either no cells, a single polyvertex cell or many vertex cells. It is more efficient with pointset input.

paraview.simple.Coordinates(*input, **params)

This filter optionally adds point locations and cell centers to point and cell data, respectively. Point locations are added in an array named PointLocations. Cell centers are added in an array named CellCenters.

paraview.simple.CountCellFaces(*input, **params)

Adds a new cell data array containing the number of faces per cell.

paraview.simple.CountCellVertices(*input, **params)

Adds a new cell data array containing the number of vertices per cell.

paraview.simple.Create2DRenderView(**params)

Create the standard 3D render view with the 2D interaction mode turned on. See CreateView() for argument documentation

paraview.simple.CreateBarChartView(**params)

Create Bar Chart view. See CreateView() for argument documentation

paraview.simple.CreateComparativeBarChartView(**params)

Create comparative Bar Chart view. See CreateView() for argument documentation

paraview.simple.CreateComparativeRenderView(**params)

Create Comparative view. See CreateView() for argument documentation

paraview.simple.CreateComparativeXYPlotView(**params)

Create comparative XY plot Chart view. See CreateView() for argument documentation

paraview.simple.CreateExtractor(name, proxy=None, registrationName=None)

Creates a new extractor and returns it.

Parameters

• name (str, optional) – The type of the extractor to create.

• proxy (paraview.servermanager.Proxy, optional) – The proxy to generate the extract from. If not specified the active source is used.

• registrationName – The registration name to use to register the extractor with the ProxyManager. If not specified a unique name will be generated.

Returns

The extractor created, on success, else None

Return type

paraview.servermanager.Proxy or None

paraview.simple.CreateLayout(name=None)

Create a new layout with no active view.

Parameters

name – The name of the layout. Optional, defaults to an automatically created name.

paraview.simple.CreateLight()

Makes a new light and returns it, unattached to a view.

Returns

The new light

Return type

paraview.servermanager.Light

paraview.simple.CreateLookupTable(**params)

Create and return a lookup table.

Parameters

params – A variadic list of key=value pairs giving values of specific named properties of the lookup table.

Returns

Lookup table

Return type

Lookup table proxy

paraview.simple.CreateParallelCoordinatesChartView(**params)

Create Parallel Coordinates Chart view. See CreateView() for argument documentation

paraview.simple.CreatePiecewiseFunction(**params)

Create and return a piecewise function.

Parameters

params – A variadic list of key=value pairs giving values of specific named properties of the opacity function.

Returns

Piecewise opacity function

Return type

Opacity functon proxy

paraview.simple.CreateRenderView(**params)

Create standard 3D render view. See CreateView() for argument documentation

paraview.simple.CreateSelection(proxyname, registrationname, **args)

Make a new selection source proxy. Can be either vtkSelection or vtkAppendSelection. Use this so that selection don’t show up in the pipeline.

paraview.simple.CreateSteerableParameters(steerable_proxy_type_name, steerable_proxy_registration_name='SteeringParameters', result_mesh_name='steerable')

Creates a steerable proxy for Catalyst use cases.

Parameters

• steerable_proxy_type_name (str) – Name of the proxy type to create.

• steerable_proxy_registration_name (str) – Registration name of the proxy created by this function. If not provided, defaults to “SteeringParameters”.

• result_mesh_name (str) – The name of the resulting mesh. If not provided, defaults to “steerable”.

Returns

Proxy of the specified type.

Return type

Steerable proxy.

paraview.simple.CreateTexture(filename=None, trivial_producer_key=None, proxyname=None)

Creates and returns a new ImageTexture proxy. The texture is not attached to anything by default but it can be applied to things, for example the view, like so:

GetActiveView().UseTexturedBackground = 1
GetActiveView().BackgroundTexture = CreateTexture("foo.png")

Parameters

• filename (str) – The name of the image file to load as a texture. If can be None, in which case the texture is read from a trivial producer indentified by the trivial_producer_key

• trivial_producer_key (str) – Identifier of the texture image source on the server. This is mainly used by scene importers when filename is None.

• proxyname (str) – The name for the texture when it is registered in ParaView.

Returns

The newly created texture.

Return type

Image texture proxy.

paraview.simple.CreateView(view_xml_name, **params)

Creates and returns the specified proxy view based on its name/label. Also set params keywords arguments as view properties.

Parameters

• view_xml_name – Name of the requested View as it appears in the proxy definition XML. Examples include RenderView, ImageChartView, SpreadSheetView, etc.

• params – Dictionary created from named arguments. If one of these arguments is named ‘registrationName’, the string value associated with it will be used as the name of the proxy. That name will appear in the Pipeline Browser of the ParaView GUI, and it is the name to be passed to the FindView() function to find this view. Any additional named arguments will be passed as properties to initialize the view.

Returns

The created view Python object.

Return type

paraview.simple.CreateWriter(filename, proxy=None, **extraArgs)

Creates a writer that can write the data produced by the source proxy in the given file format (identified by the extension). This function doesn’t actually write the data, it simply creates the writer and returns it

Parameters

• filename (str) – The name of the output data file.

• proxy (Source proxy.) – Source proxy whose output should be written. Optional, defaults to the creating a writer for the active source.

• extraArgs (A variadic list of key=value pairs giving values of specific named properties in the writer.) – Additional arguments that should be passed to the writer proxy.

paraview.simple.CreateXYPlotView(**params)

Create XY plot Chart view. See CreateView() for argument documentation

paraview.simple.CreateXYPointPlotView(**params)

Create XY plot point Chart view. See CreateView() for argument documentation

paraview.simple.CriticalTime(*input, **params)

Given an input that changes over time and a point/cell array, the Critical Time filter generates a new point/cell array containing time step values. These values correspond to the time at which a specified threshold criterion has been met for the selected input array, at each point/cell respectively. The name of this array is the same of the selected array with ‘_critical_time’ appended at the end. Other point/cell arrays are discarded. This filter processes all available time steps. If the criterion is never met for a given point/cell, a NaN value is assigned. The output of this filter is not temporal.

paraview.simple.Crop(*input, **params)

The Crop filter

extracts an area/volume of interest from a 2D image or a 3D volume by allowing the user to specify the minimum and maximum extents of each dimension of the data. Both the input and output of this filter are uniform rectilinear data.

paraview.simple.Curvature(*input, **params)

The

Curvature filter computes the curvature at each point in a polygonal dataset. This filter supports both Gaussian and mean curvatures. The type can be selected from the Curvature type combobox.

paraview.simple.Cylinder(*input, **params)

The

Cylinder source can be used to add a polygonal cylinder to the 3D scene. The output of the Cylinder source is polygonal data containing both normals and texture coordinates.

paraview.simple.D3(*input, **params)

The D3 filter is available when ParaView is run in parallel. It operates on any type of data set to evenly divide it across the processors into spatially contiguous regions. The output of this filter is of type unstructured grid.

paraview.simple.DEMReader(*input, **params)

The DEM reader

reads Digital Elevation Model files containing elevation values derived from the U. S. Geologic Survey. The default file extension is .dem. This reader produces uniform rectilinear (image/volume) data output.

paraview.simple.DICOMReaderSingleFile(*input, **params)

DICOM is a file format often used in medical imaging. This version of the reader reads a single file (as opposed to a collection of files). The DICOM reader currently only supports uncompressed files.

paraview.simple.DICOMReaderdirectory(*input, **params)

DICOM is a file format often used in medical imaging. This version of the reader will look at all files in the same directory of the selected file and load them as planes of the same data set. It is typically for 3D medical scanners to store planes as set of files in a directory.

paraview.simple.DataObjectGenerator(*input, **params)

vtkDataObjectGenerator parses a string and produces dataobjects from the dataobject template names it sees in the string. For example, if the string contains “ID1” the generator will create a vtkImageData. “UF1”, “RG1”, “SG1”, “PD1”, and “UG1” will produce vtkUniformGrid, vtkRectilinearGrid, vtkStructuredGrid, vtkPolyData and vtkUnstructuredGrid respectively. “PD2” will produce an alternate vtkPolyData. You can compose composite datasets from the atomic ones listed above - “MB{}” or “HB[]”. “MB{ ID1 PD1 MB{} }” for example will create a vtkMultiBlockDataSet consisting of three blocks: image data, poly data, multiblock (empty). Hierarchical Box data sets additionally require the notion of groups, declared within “()” braces, to specify AMR depth. “HB[ (UF1)(UF1)(UF1) ]” will create a vtkHierarchicalBoxDataSet representing an octree that is three levels deep, in which the first cell in each level is refined.

paraview.simple.DataSetCSVWriter(*input, **params)

paraview.simple.DataSetWriter(*input, **params)

Writer to write any type of data object in a legacy vtk data file. Cannot be used for parallel writing.

paraview.simple.DateToNumeric(*input, **params)

The DateToNumeric filter looks at string arrays in the input data object. If they contain dates that can be converted numbers then they are converted to doubles and added as additional arrays of the same type (point/cell/field). The format string used to parse dates can be specified by the user.

paraview.simple.Decimate(*input, **params)

The Decimate filter reduces the number of triangles in a polygonal data set. Because this filter only operates on triangles, first run the Triangulate filter on a dataset that contains polygons other than triangles.

paraview.simple.DecimatePolyline(*input, **params)

Decimate Polyline is a filter to reduce the number of lines in a polyline. The algorithm functions by evaluating an error metric for each vertex (i.e., the distance of the vertex to a line defined from the two vertices on either side of the vertex). Then, these vertices are placed into a priority queue, and those with smaller errors are deleted first. The decimation continues until the target reduction is reached. While the filter will not delete end points, it will decimate closed loops down to a single line, thereby changing topology.

As this filter works on polylines, you may need to call Triangle Strips before calling this filter.

paraview.simple.DeflectNormals(*input, **params)

paraview.simple.Delaunay2D(*input, **params)

Delaunay2D is a filter that constructs a 2D Delaunay triangulation from a list of input points. These points may be represented by any dataset of type vtkPointSet and subclasses. The output of the filter is a polygonal dataset containing a triangle mesh. The 2D Delaunay triangulation is defined as the triangulation that satisfies the Delaunay criterion for n-dimensional simplexes (in this case n=2 and the simplexes are triangles). This criterion states that a circumsphere of each simplex in a triangulation contains only the n+1 defining points of the simplex. In two dimensions, this translates into an optimal triangulation. That is, the maximum interior angle of any triangle is less than or equal to that of any possible triangulation. Delaunay triangulations are used to build topological structures from unorganized (or unstructured) points. The input to this filter is a list of points specified in 3D, even though the triangulation is 2D. Thus the triangulation is constructed in the x-y plane, and the z coordinate is ignored (although carried through to the output). You can use the option ProjectionPlaneMode in order to compute the best-fitting plane to the set of points, project the points and that plane and then perform the triangulation using their projected positions and then use it as the plane in which the triangulation is performed. The Delaunay triangulation can be numerically sensitive in some cases. To prevent problems, try to avoid injecting points that will result in triangles with bad aspect ratios (1000:1 or greater). In practice this means inserting points that are “widely dispersed”, and enables smooth transition of triangle sizes throughout the mesh. (You may even want to add extra points to create a better point distribution.) If numerical problems are present, you will see a warning message to this effect at the end of the triangulation process. Warning: Points arranged on a regular lattice (termed degenerate cases) can be triangulated in more than one way (at least according to the Delaunay criterion). The choice of triangulation (as implemented by this algorithm) depends on the order of the input points. The first three points will form a triangle; other degenerate points will not break this triangle. Points that are coincident (or nearly so) may be discarded by the algorithm. This is because the Delaunay triangulation requires unique input points. The output of the Delaunay triangulation is supposedly a convex hull. In certain cases this implementation may not generate the convex hull.

paraview.simple.Delaunay3D(*input, **params)

Delaunay3D is a filter that constructs a 3D Delaunay triangulation from a list of input points. These points may be represented by any dataset of type vtkPointSet and subclasses. The output of the filter is an unstructured grid dataset. Usually the output is a tetrahedral mesh, but if a non-zero alpha distance value is specified (called the “alpha” value), then only tetrahedra, triangles, edges, and vertices lying within the alpha radius are output. In other words, non-zero alpha values may result in arbitrary combinations of tetrahedra, triangles, lines, and vertices. (The notion of alpha value is derived from Edelsbrunner’s work on “alpha shapes”.) The 3D Delaunay triangulation is defined as the triangulation that satisfies the Delaunay criterion for n-dimensional simplexes (in this case n=3 and the simplexes are tetrahedra). This criterion states that a circumsphere of each simplex in a triangulation contains only the n+1 defining points of the simplex. (See text for more information.) While in two dimensions this translates into an “optimal” triangulation, this is not true in 3D, since a measurement for optimality in 3D is not agreed on. Delaunay triangulations are used to build topological structures from unorganized (or unstructured) points. The input to this filter is a list of points specified in 3D. (If you wish to create 2D triangulations see Delaunay2D.) The output is an unstructured grid. The Delaunay triangulation can be numerically sensitive. To prevent problems, try to avoid injecting points that will result in triangles with bad aspect ratios (1000:1 or greater). In practice this means inserting points that are “widely dispersed”, and enables smooth transition of triangle sizes throughout the mesh. (You may even want to add extra points to create a better point distribution.) If numerical problems are present, you will see a warning message to this effect at the end of the triangulation process. Warning: Points arranged on a regular lattice (termed degenerate cases) can be triangulated in more than one way (at least according to the Delaunay criterion). The choice of triangulation (as implemented by this algorithm) depends on the order of the input points. The first four points will form a tetrahedron; other degenerate points (relative to this initial tetrahedron) will not break it. Points that are coincident (or nearly so) may be discarded by the algorithm. This is because the Delaunay triangulation requires unique input points. You can control the definition of coincidence with the “Tolerance” instance variable. The output of the Delaunay triangulation is supposedly a convex hull. In certain cases this implementation may not generate the convex hull. This behavior can be controlled by the Offset instance variable. Offset is a multiplier used to control the size of the initial triangulation. The larger the offset value, the more likely you will generate a convex hull; and the more likely you are to see numerical problems. The implementation of this algorithm varies from the 2D Delaunay algorithm (i.e., Delaunay2D) in an important way. When points are injected into the triangulation, the search for the enclosing tetrahedron is quite different. In the 3D case, the closest previously inserted point point is found, and then the connected tetrahedra are searched to find the containing one. (In 2D, a “walk” towards the enclosing triangle is performed.) If the triangulation is Delaunay, then an enclosing tetrahedron will be found. However, in degenerate cases an enclosing tetrahedron may not be found and the point will be rejected.

paraview.simple.Delete(proxy=None)

Deletes the given pipeline source or the active source if no argument is specified.

Parameters

proxy (Source proxy. Optional, defaults to deleting the active source.) – the proxy to remove

paraview.simple.DescriptiveStatistics(*input, **params)

This filter either computes a statistical model of a dataset or takes such a model as its second input. Then, the model (however it is obtained) may optionally be used to assess the input dataset.<p> This filter computes the min, max, mean, raw moments M2 through M4, standard deviation, skewness, and kurtosis for each array you select.<p> The model is simply a univariate Gaussian distribution with the mean and standard deviation provided. Data is assessed using this model by detrending the data (i.e., subtracting the mean) and then dividing by the standard deviation. Thus the assessment is an array whose entries are the number of standard deviations from the mean that each input point lies.

paraview.simple.Disconnect(ns=None, force=True)

Disconnect from the currently connected server and free the active session. Does not shut down the client application where the call is executed.

Parameters

• ns (Dict or None) – Namespace in which ParaView functions were created. Optional, defaults to the namespace returned by globals()

• force (bool) – Force disconnection in a simultaneous connection. Optional, defaults to forcing disconnection.

paraview.simple.Disk(*input, **params)

The Disk source can be used

to add a polygonal disk to the 3D scene. The output of the Disk source is polygonal data.

paraview.simple.DistributePoints(*input, **params)

This filter fairly distributes points over processors into contiguous spatial regions. The output is a PolyData which does not contain any cell. Distribution is done using a Kd-tree.

paraview.simple.DistributedTrivialProducer(*input, **params)

paraview.simple.ENZOAMRParticlesReader(*input, **params)

The

Enzo particles reader loads particle simulation data stored in Enzo HDF5 format. The output of this reader is MultiBlock dataset where each block is a vtkPolyData that holds the particles (points) and corresponding particle data.

paraview.simple.ERFHDF5datareader(*input, **params)

Reads ERF HDF5 serial data files.

paraview.simple.Elevation(*input, **params)

The Elevation filter generates point scalar values for an input dataset along a specified direction vector. The Input menu allows the user to select the data set to which this filter will be applied. Use the Scalar range entry boxes to specify the minimum and maximum scalar value to be generated. The Low Point and High Point define a line onto which each point of the data set is projected. The minimum scalar value is associated with the Low Point, and the maximum scalar value is associated with the High Point. The scalar value for each point in the data set is determined by the location along the line to which that point projects.

paraview.simple.Ellipse(*input, **params)

Source that creates an elliptical arc defined by a normal, a center, a major radius vector (the direction in which the ellipse is longest), and a ratio defined as the minor radius over the major radius. A starting angle and segment angle control the starting and ending points on the ellipse perimeter, enabling creation of only a section of the ellipse. The number of segments in the polyline is controlled by setting the object resolution.

paraview.simple.EnSightMasterServerReader(*input, **params)

The EnSight

Master Server reader reads EnSight’s parallel files. The master file usually has a .sos extension and may point to multiple .case files. The output is a multiblock dataset. This is a distributed reader.

paraview.simple.EnSightReader(*input, **params)

The EnSight reader reads

files in the format produced by CEI’s EnSight. EnSight 6 and Gold files (both ASCII and binary) are supported. The default extension is .case. The output of this reader is a multiblock dataset. This is a distributed reader.

paraview.simple.EnSightWriter(*input, **params)

Writer to write unstructured grid data as an EnSight file. Binary files written on one system may not be readable on other systems. Be sure to specify the endian-ness of the file when reading it into EnSight.

paraview.simple.EnsembleDataReader(*input, **params)

Reads CSV files in which each row gives a dataset and the last column of each row specifies the file name for the dataset. The standard extension is .pve.

paraview.simple.EnvironmentAnnotation(*input, **params)

Apply to any source. Gui allows manual selection of desired annotation options. If the source is a file, can display the filename.

paraview.simple.EnzoReader(*input, **params)

This Enzo reader loads data stored in Enzo format. The output of this reader is a hierarchical-box dataset.

paraview.simple.EqualizeViewsBoth(layout=None)

Equalizes the vertical and horizontal view sizes in the provided layout.

Parameters

layout (Layout proxy.) – Layout the layout contain the views to equalize. Optional, defaults to the active layout.

paraview.simple.EqualizeViewsHorizontally(layout=None)

Equalizes horizontal view sizes in the provided layout.

Parameters

layout (Layout proxy.) – Layout the layout contain the views to equalize. Optional, defaults to the active layout.

paraview.simple.EqualizeViewsVertically(layout=None)

Equalizes vertical view sizes in the provided layout.

Parameters

layout (Layout proxy.) – Layout the layout contain the views to equalize. Optional, defaults to the active layout.

paraview.simple.EqualizerFilter(*input, **params)

The Equalizer Filter implements an algorithm that selectively corrects the signal amplitude depending on the frequency characteristics.

paraview.simple.EvenlySpacedStreamlines2D(*input, **params)

This filter generates evenly spaced streamlines in a 2D vector field from a start position. Production of streamlines terminates if a streamline crosses the exterior boundary of the input dataset (ReasonForTermination=1), an initialization issue (ReasonForTermination=2), computing an unexpected value (ReasonForTermination=3), reached the Maximum Streamline Length input value (ReasonForTermination=4), reached the Maximum Steps input value (ReasonForTermination=5), velocity was lower than the Terminal Speed input value (ReasonForTermination=6), a streamline formed a loop (ReasonForTermination=7), and the streamline was too close to other streamlines (ReasonForTermination=8). This filter operates on a 2D dataset aligned with plane XY with point-centered vectors aligned with plane XY. The output is polygonal data containing polylines.

paraview.simple.ExodusIIReader(*input, **params)

The Exodus reader loads

Exodus II files and produces an unstructured grid output. The default file extensions are .g, .e, .ex2, .ex2v2, .exo, .gen, .exoII, .exii, .frq, .0, .00, .000, and .0000. The file format is described fully at: http://endo.sandia.gov/SEACAS/Documentation/exodusII.pdf. Each Exodus file contains a single set of points with 2-D or 3-D coordinates plus one or more blocks, sets, and maps. Block group elements (or their bounding edges or faces) of the same type together. Sets select subsets (across all the blocks in a file) of elements, sides of elements (which may be of mixed dimensionality), bounding faces of volumetric elements, or bounding edges of volumetric or areal elements. Each block or set may have multiple result variables, each of which defines a value per element, per timestep. The elements (cells), faces of elements (when enumerated in face blocks), edges of elements (when enumerated in edge blocks), and nodes (points) in a file may be assigned an arbitrary integer number by an element map, face map, edge map, or node map, respectively. Usually, only a single map of each type exists and is employed to assign a unique global ID to entities across multiple files which partition a large mesh for a distributed-memory calculation. However here may be multiply maps of each type and there are no constraints which force the integers to be unique. The connectivity of elements is constant across all of the timesteps in any single Exodus II file. However, multiple files which specify a single time-evolution of a mesh may be used to represent meshes which exhibit changes in connectivity infrequently. Field variable mode_shape[0] represents the time step (t_index) if HasModeShapes is not set or the ModeShape otherwise. This is a distributed reader.

paraview.simple.ExodusIIWriter(*input, **params)

Writer to write Exodus

II files. Refere to http://endo.sandia.gov/SEACAS/ for more information about the Exodus II format.

paraview.simple.ExplodeDataSet(*input, **params)

Explode the input DataSet into a composite (PartitionedDataSetCollection) by extracting cells based on a cell scalar iso-value criteria. This is typically useful when the input has some material (or region) ids set on cells. Then the output is a composite, where each partition corresponds to one id. See Connectivity and FeatureEdgesRegionIds filters.

paraview.simple.ExponentialKeyFrame(*input, **params)

paraview.simple.ExportTransferFunction(colortransferfunction, opacitytransferfunction, tfname, filename, location=16)

Export transfer function to a file. The file will be saved in the new JSON format.

Parameters

• colortransferfunction (Color transfer function proxy.) – The color transfer function to export.

• opacitytransferfunction (Opacity transfer function proxy.) – The opacity transfer functon to export, if provided. can be None.

• tfname (str) – The name that will be given to the transfer function preset if imported back into ParaView.

• filename (str) – Path to file where exported transfer function should be saved.

• location (vtkPVServer.ServerFlags enum value) – Where the statefile should be saved, e.g., pass vtkPVSession.CLIENT if the statefile is located on the client system (default value), pass in vtkPVSession.SERVERS if on the server. Optional, defaults to vtkPVSession.CLIENT.

Returns

True on success, False otherwise.

paraview.simple.ExportView(filename, view=None, **params)

Export a view to the specified output file. Based on the view and file extension, an exporter of the right type will be chosen to export the view.

Parameters

• filename (str) – Name of the exported file.

• view (View proxy.) – The view proxy to export. Optional, defaults to the active view.

• params – A variadic list of key=value pairs giving values of specific named properties of the exporter.

paraview.simple.ExtendFileSeries(proxy=None)

For a reader proxy that supports reading files series, detect any new files added to the series and update the reader’s filename property.

Parameters

proxy – Reader proxy that should check for a extended file series. Optional, defaults to extending file series in the active source.

Returns

True if the operation succeeded, False otherwise

Return type

bool

paraview.simple.ExtractAMRBlocks(*input, **params)

This filter extracts a list of datasets from hierarchical datasets.

paraview.simple.ExtractAttributes(*input, **params)

This is a

filter that produces a vtkTable from the chosen attribute in the input data object. This filter can accept composite datasets. If the input is a composite dataset, the output is a multiblock with vtkTable leaves.

paraview.simple.ExtractBlock(*input, **params)

Extract selected blocks from a composite dataset.

paraview.simple.ExtractCTHParts(*input, **params)

Extract

CTH Parts is a specialized filter for visualizing the data from a CTH simulation. It first converts the selected cell-centered arrays to point-centered ones. It then contours each array at a value of 0.5. The user has the option of clipping the resulting surface(s) with a plane. This filter only operates on unstructured data. It produces polygonal output.

paraview.simple.ExtractCellsAlongLine(*input, **params)

This filter extract the cells intersected by a line.

paraview.simple.ExtractCellsAlongLinesCustomSource(*input, **params)

The Extract Cells Along Lines From Custom Source filter extracts cells from the input data set that intersect lines from a custom source. This source can be either an Unstructured Grid or a Poly Data. Any cells other than lines or poly lines are ignored in the source.

paraview.simple.ExtractCellsByRegion(*input, **params)

This filter extracts from its input dataset all cells that are either completely inside or outside of a specified region (implicit function). On output, the filter generates an unstructured grid. To use this filter you must specify a region (implicit function). You must also specify whether to extract cells lying inside or outside of the region. An option exists to extract cells that are neither inside or outside (i.e., boundary).

paraview.simple.ExtractCellsByType(*input, **params)

This filter extracts cells of the selected types. If the data set does not contain cells of the chosen types, the output is empty.

paraview.simple.ExtractComponent(*input, **params)

paraview.simple.ExtractEdges(*input, **params)

The Extract Edges

filter produces a wireframe version of the input dataset by extracting all the edges of the dataset’s cells as lines. This filter operates on any type of data set and produces polygonal output.

paraview.simple.ExtractEnclosedPoints(*input, **params)

Evaluates all points in the input dataset to determine whether they are contained within an enclosing surface, defined by the Surface. The filter assumes that the surface is closed and manifold. To force a check to ensure these preconditions are met set the CheckSurface property.

paraview.simple.ExtractGenericDatasetSurface(*input, **params)

Extract geometry from a higher-order dataset.

paraview.simple.ExtractGhostCells(*input, **params)

This filter extracts the ghost cells from the input and displays them so one can inspect them visually.

paraview.simple.ExtractLocation(*input, **params)

This filter allows you to specify a location and then either interpolate the data attributes from the input dataset at that location or extract the cell(s) at the location.

paraview.simple.ExtractParticlesOverTime(*input, **params)

This filter extracts input particles passing through a volume by iterating over time. The filter has two inputs: Particles and Volume. The Particles input should contain points evolving over time and the Volume input is expected to be a volumetric dataset. The output is a subset of the particles from the input, still temporal.

paraview.simple.ExtractRegionSurface(*input, **params)

The Extract

Surface filter extracts the polygons forming the outer surface of the input dataset. This filter operates on any type of data and produces polygonal data as output.

paraview.simple.ExtractSelection(*input, **params)

This filter extracts a set of cells/points given a selection. The selection can be obtained from a rubber-band selection (either cell, visible or in a frustum) or threshold selection and passed to the filter or specified by providing an ID list.

paraview.simple.ExtractSelectioninternal(*input, **params)

This filter extracts a given set of cells or points given a selection. The selection can be obtained from a rubber-band selection (either point, cell, visible or in a frustum) and passed to the filter or specified by providing an ID list. This is an internal filter, use “ExtractSelection” instead.

paraview.simple.ExtractSubset(*input, **params)

The Extract

Grid filter returns a subgrid of a structured input data set (uniform rectilinear, curvilinear, or nonuniform rectilinear). The output data set type of this filter is the same as the input type.

paraview.simple.ExtractSubsetWithSeed(*input, **params)

Extract a subset (line or plane) from a structured-grid starting with a seed point. The filter supports cases where the structured grid is split up into multiple blocks (across multiple ranks). It also handles cases were the ijk origin for each the blocks is not aligned.

paraview.simple.ExtractSurface(*input, **params)

The Extract Surface filter extracts the polygons forming the outer surface of the input dataset. This filter operates on any type of data and produces polygonal data as output.

paraview.simple.ExtractTimeSteps(*input, **params)

This filter extracts specified time steps from its input.

paraview.simple.FDSReader(*input, **params)

A reader relying on .smv files to read outputs from the Fire Dynamics Simulator (FDS) code.

paraview.simple.FFTOfSelectionOverTime(*input, **params)

Extracts the data of a selection (e.g. points or cells) over time, takes the FFT of them, and plots them.

paraview.simple.FLASHAMRParticlesReader(*input, **params)

The

Flash particles reader loads particle simulation data stored in Flash format. The output of this reader is a MultiBlock dataset where each block is vtkPolyData that holds the particles and corresponding particle data.

paraview.simple.FacetReader(*input, **params)

The Facet

Reader reads files in Facet format: a simple ASCII file format listing point coordinates and connectivity between these points. The default file extension is .facet. The output of the Facet Reader is polygonal.

paraview.simple.FastUniformGrid(*input, **params)

The

Fast Uniform Grid source can be used to create a uniform grid with scalar values derived from relatively light computations. The active scalar array is named “X”, and is set to the X coordinate for each pixel. There are two additional point data sets. The data array named “DistanceSquared” is computed as the squared distance from each pixel to the origin. The data array named “Swirl” is a vector field computed as (Y,Z,X) at each pixel.

paraview.simple.FeatureEdges(*input, **params)

The Feature Edges filter extracts various subsets of edges from the input data set. This filter operates on polygonal data or hyper tree grids and produces polygonal output.

paraview.simple.FeatureEdgesRegionIds(*input, **params)

Generates a region ids cell array. A region is defined as a collection of connected cells with a maximal angle between their normals.

Grouping cells into regions is similar to Connectivity filter, while the Normal criteria is similar to Feature Edges computation.

Note: Duplicated points may create unexpected regions. It is advised to run a Clean filter to remove them.

Warning: FeatureEdgesRegionIds is not implemented for Distributed environment.

paraview.simple.FetchData(proxy=None, **kwargs)

Fetches data from the specified data producer for processing locally. Use this function with caution since this can cause large amounts of data to be gathered and delivered to the client.

If no producer is specified, the active source is used.

Basic Usage

#to fetch data from port 0

dataMap = FetchData(producer)

# to fetch data from a specific port

dataMap = FetchData(OutputPort(producer, 1))

FetchData() does not explicitly update the pipeline. It is expected that the pipeline is already updated. This will simply deliver the current data.

Returns a map where the key is an integer representing a rank and value is the dataset fetched from that rank.

Keyword Parameters

The following keyword parameters can be used to customize the fetchs.

GatherOnAllRanks (bool/int, optional):

This is used only in symmetric batch (or ParaView-Catalyst) mode. If True, then FetchData() will gather the data on all ranks. Default is to only gather the data on the root node.

SourceRanks (list(int), optional):

List of ints to specity explicitly the ranks from which to fetch data. By default, data from all ranks is fetched.

paraview.simple.FieldArraysFromFile(*input, **params)

Takes in an input data object and a filename. Opens the file and adds any arrays it sees there to the input data.

paraview.simple.FieldDatatoAttribute(*input, **params)

This filter creates single-value arrays in the requested field from the selected Field Data arrays.

It uses only the first component of the first tuple of the input arrays. This filter operates on any type of dataset, and the output dataset is the same type as the input. String arrays are not supported.

paraview.simple.FindExtractor(registrationName)

Returns an extractor with a specific registrationName.

Parameters

registrationName (str) – Registration name for the extractor.

Returns

The extractor or None

Return type

paraview.servermanager.Proxy or None

paraview.simple.FindSource(name)

Return a pipeline source based on the name that was used to register it with ParaView.

Example usage:

Cone(guiName='MySuperCone')
Show()
Render()
myCone = FindSource('MySuperCone')

Parameters

name (str) – The name that the pipeline source was registered with during creation or after renaming.

Returns

The pipeline source if found.

Return type

Pipeline source proxy.

paraview.simple.FindTextureOrCreate(registrationName, filename=None, trivial_producer_key=None)

Finds or creates a new ImageTexture proxy.

Parameters

• registrationName (str) – The name for the texture when it is registered in ParaView.

• filename (str) – Path to the texture image source file. Optional, if not provided, the trivial_producer_key should be provided to tell which image source to use for the texture.

• trivial_producer_key (str) – Identifier of the texture image source on the server. This is mainly used by scene importers when filename is None.

paraview.simple.FindView(name)

Return a view proxy based on the name that was used to register it with ParaView.

Example usage:

CreateRenderView(guiName='RenderView1')
myView = FindSource('RenderView1')

Parameters

name (str) – The name that the view was registered with during creation or after renaming.

Returns

The view if found.

Return type

View proxy.

paraview.simple.FindViewOrCreate(name, viewtype)

Returns the view if a view with the given name exists and is of the the given viewtype, otherwise creates a new view of the requested type. Note, if a new view is created, it will be assigned to a layout by calling AssignViewToLayout.

Parameters

• name (str) – Name of the view to find.

• viewtype (str) – Type of the view to create.

paraview.simple.FiniteElementFieldDistributor(*input, **params)

paraview.simple.FlashReader(*input, **params)

This Flash reader loads data stored in Enzo format. The output of this reader is a hierarchical-box dataset.

paraview.simple.FluentCFFCaseReader(*input, **params)

FLUENTCFFReader creates an unstructured grid dataset. It reads .cas.h5 and .dat.h5 files stored in FLUENT CFF format.

paraview.simple.FluentCaseReader(*input, **params)

FLUENTReader creates an unstructured grid dataset. It reads .cas and .dat files stored in FLUENT native format (or a file series of the same.

paraview.simple.ForceStaticMesh(*input, **params)

The Force Static Mesh filter create a cache the first time it is executed using its input. It will then only update PointData, CellData and FieldData from the input as long as their dimensions stay the same. This filter operates only on a vtkUnstructuredGrid input or on the first block of a multiblock input if it is a vtkUnstructuredGrid.

paraview.simple.ForceTime(*input, **params)

Filter used to explicitly request a specific time from the pipeline.

paraview.simple.FrustumSelectionSource(*input, **params)

FrustumSelectionSource is a source producing a frustum selection.

paraview.simple.GaussianCubeReader(*input, **params)

The Gaussian

Cube reader produces vtkMolecule data by reading data files produced by the Gaussian software package. The expected file extension is .cube.

paraview.simple.GaussianResampling(*input, **params)

vtkGaussianSplatter

is a filter that injects input points into a structured points (volume) dataset. As each point is injected, it “splats” or distributes values to nearby voxels. Data is distributed using an elliptical, Gaussian distribution function. The distribution function is modified using scalar values (expands distribution) or normals (creates ellipsoidal distribution rather than spherical). Warning: results may be incorrect in parallel as points can’t splat into other processor’s cells.

paraview.simple.GenerateGlobalIds(*input, **params)

GenerateGlobalIds is a deprecated proxy. It will be automatically replaced by GlobalPointAndCellIds

paraview.simple.GenerateIds(*input, **params)

GenerateIds is a deprecated proxy. It will be automatically replaced by PointAndCellIds

paraview.simple.GenerateProcessIds(*input, **params)

GenerateProcessIds is a deprecated proxy. It will be automatically replaced by ProcessIds

paraview.simple.GenerateQuadraturePoints(*input, **params)

Create a point set with data at quadrature points.

paraview.simple.GenerateQuadratureSchemeDictionary(*input, **params)

Generate quadrature scheme dictionaries in datasets that do not have them.

paraview.simple.GenerateSpatioTemporalHarmonics(*input, **params)

GenerateSpatioTemporalHarmonics is a deprecated proxy. It will be automatically replaced by SpatioTemporalHarmonics

paraview.simple.GenerateSurfaceNormals(*input, **params)

GenerateSurfaceNormals is a deprecated proxy. It will be automatically replaced by SurfaceNormals

paraview.simple.GenerateSurfaceTangents(*input, **params)

GenerateSurfaceTangents is a deprecated proxy. It will be automatically replaced by SurfaceTangents

paraview.simple.GenerateTimeSteps(*input, **params)

This filter generate timesteps on any input, it completely ignores input time steps if any.

paraview.simple.GeometryFilter(*input, **params)

paraview.simple.GetActiveCamera()

Returns the active camera for the active view.

Returns

The active camera

Return type

vtkCamera

paraview.simple.GetActiveSource()

Returns the active source.

Returns

Active pipeline source.

Return type

Source proxy

paraview.simple.GetActiveView()

Returns the active view.

Returns

Active view.

Return type

View proxy.

paraview.simple.GetActiveViewOrCreate(viewtype)

Returns the active view if the active view is of the given type, otherwise creates a new view of the requested type. Note, if a new view is created, it will be assigned to a layout by calling AssignViewToLayout().

Parameters

viewtype (str) – The type of view to access if it is the active view or create if it doesn’t exist.

Returns

The active view if it is of type viewtype.

Return type

View proxy.

paraview.simple.GetAllSettings()

Get a list of strings that return valid settings proxy types for the :func:GetSettingsProxy() function.

Returns

List of valid settings proxy names

Return type

list of str

paraview.simple.GetAnimationScene()

Returns the application-wide animation scene. ParaView has only one global animation scene. This method provides access to that. You are free to create additional animation scenes directly, but those scenes won’t be shown in the ParaView GUI.

Returns

The animation scene

Return type

paraview.servermanager.AnimationScene

paraview.simple.GetAnimationTrack(propertyname_or_property, index=None, proxy=None)

Returns an animation cue for the property. If one doesn’t exist then a new one will be created. Typical usage:

track = GetAnimationTrack("Center", 0, sphere) or
track = GetAnimationTrack(sphere.GetProperty("Radius")) or

# this returns the track to animate visibility of the active source in
# all views.
track = GetAnimationTrack("Visibility")

For animating properties on implicit planes etc., use the following signatures:

track = GetAnimationTrack(slice.SliceType.GetProperty("Origin"), 0) or
track = GetAnimationTrack("Origin", 0, slice.SliceType)

paraview.simple.GetBlockColorTransferFunction(selector, arrayname, representation=None, separate=False, **params)

Get the color transfer function used to map a data array with the given name to colors in the blocks referred to by a selector expresson.

Parameters

• selector (str) – Selector expression used to select blocks from whom the color transfer should be retrieved.

• arrayname (str) – Name of the array whose color transfer function is requested.

• representation (Representation proxy.) – Used to modify the array name when using a separate color transfer function. Optional, defaults to the active proxy.

• separate (bool) – If True, used to recover the separate color transfer function even if it is not used currently by the representation. Optional, defaults to False.

Returns

This may create a new color transfer function if none exists, or return an existing one if found.

Return type

Color transfer function proxy

paraview.simple.GetCameraTrack(view=None)

Returns the camera animation track for the given view.

Parameters

view (View proxy) – The view whose camera animation track should be retrieved. If no view is specified, the active view will be used. If no existing camera animation track is found, a new one will be created.

Returns

Camera animation cue

Return type

paraview.servermanager.CameraAnimationCue

paraview.simple.GetColorTransferFunction(arrayname, representation=None, separate=False, **params)

Get the color transfer function used to map a data array with the given name to colors.

Parameters

• arrayname (str) – Name of the array whose color transfer function is requested.

• representation (Representation proxy.) – Used to modify the array name when using a separate color transfer function. Optional, defaults to the active proxy.

• separate (bool) – If True, used to recover the separate color transfer function even if it is not used currently by the representation. Optional, defaults to False.

Returns

This may create a new color transfer function if none exists, or return an existing one if found.

Return type

Color transfer function proxy

paraview.simple.GetDisplayProperties(proxy=None, view=None)

DEPRECATED: Should use GetRepresentation() instead.

paraview.simple.GetDisplayProperty(*arguments, **keywords)

DEPRECATED: Should use GetRepresentationProperty()

paraview.simple.GetExtractors(proxy=None)

Returns a list of extractors associated with the proxy.

Parameters

proxy (paraview.servermanager.Proxy, optional) – The proxy to return the extractors associated with. If not specified (or is None) then all extractors are returned.

Returns

List of associated extractors if any. May return an empty list.

Return type

list of paraview.servermanager.Proxy

paraview.simple.GetLayout(view=None)

Return the layout containing the given view, if any.

Parameters

view – A view in the layout to be removed. Optional, defaults to the active view.

Returns

The layout containing the view

Return type

paraview.servermanager.ViewLayout

paraview.simple.GetLayoutByName(name)

Return the first layout with the given name, if any.

Parameters

name (str) – Name of the layout

Returns

The named layout if it exists

Return type

Layout proxy or None

paraview.simple.GetLayouts()

Returns all the layout proxies.

Returns

A list of all the layouts.

Return type

list of layout proxies

paraview.simple.GetLight(number, view=None)

Get a previously added light.

Parameters

• number (int) – The index of the light to obtain.

• view (View proxy. Option, if not provided the active view is used.) – The view holding the light.

Returns

The requested light.

Return type

paraview.servermanager.Light or None

paraview.simple.GetLookupTableNames()

Returns a list containing the currently available transfer function preset names.

Returns

List of currently availabe transfer function preset names.

Return type

List of str

paraview.simple.GetMaterialLibrary()

Returns the material library for the active session.

Returns

The material library

Return type

paraview.servermanager.MaterialLibrary

paraview.simple.GetNumberOfCallbackThreads(n)

Gets the number of threads used by the threaded callback queue that can be used for saving screenshots.

Parameters

n (int) – Not used

paraview.simple.GetNumberOfSMPThreads(n)

paraview.simple.GetOpacityTransferFunction(arrayname, representation=None, separate=False, **params)

Get the opacity transfer function used to map a data array with the given name to opacities in the blocks referred to by a selector expresson.

Parameters

• arrayname (str) – Name of the array whose opacity transfer function is requested.

• representation (Representation proxy.) – Used to modify the array name when using a separate opacity transfer function. Optional, defaults to the active representation.

• separate (bool) – If True, used to recover the separate opacity transfer function even if it is not used currently by the representation. Optional, defaults to False.

Returns

This may create a new opacity transfer function if none exists, or return an existing one if found.

Return type

Opacity transfer function proxy

paraview.simple.GetOpenGLInformation(location=16)

Recover OpenGL information on either the client or server.

Parameters

location (vtkPVServer.ServerFlags enum value) – Where the OpenGL information should be retrieved, e.g., pass vtkPVSession.CLIENT if you want OpenGL info from the client system (default value), pass in vtkPVSession.SERVERS if you want the server.

paraview.simple.GetParaViewSourceVersion()

Returns

the ParaView source version string, e.g., ‘paraview version x.x.x, Date: YYYY-MM-DD’.

Return type

str

paraview.simple.GetParaViewVersion()

Returns

The version of the ParaView build in (major, minor) form.

Return type

2-element tuple

paraview.simple.GetProperty(*arguments, **keywords)

Get one property of the given pipeline object. If keywords are used, you can set the proxy and the name of the property that you want to get as shown in the following example:

GetProperty({proxy=sphere, name="Radius"})

If arguments are used, then you have two cases:

• if only one argument is used that argument will be the property name.

• if two arguments are used then the first one will be the proxy and the second one the property name.

Several example are given below:

GetProperty(name="Radius")
GetProperty(proxy=sphereProxy, name="Radius")
GetProperty( sphereProxy, "Radius" )
GetProperty( "Radius" )

paraview.simple.GetRenderView()

Returns the active view if there is one. Else creates and returns a new view. :return: the active view

paraview.simple.GetRenderViews()

Get all render views in a list. :return: all render views in a list.

paraview.simple.GetRepresentation(proxy=None, view=None)

Given a pipeline proxy and a view, returns the corresponding representation object. If proxy and view are not specified, active objects are used.

Parameters

• proxy (Source proxy) – Pipeline proxy whose representation in the given view is requested. Optional, defaults to the active view.

• view (View proxy) – The view associated with the requested representation. Optional, defaults to returning the representation associated with the active view.

Returns

The representation for the given proxy in the view.

Return type

Representation proxy

paraview.simple.GetRepresentationAnimationHelper(sourceproxy)

Method that returns the representation animation helper for a source proxy. It creates a new one if none exists.

paraview.simple.GetRepresentationProperty(*arguments, **keywords)

Same as GetProperty(), except that if no proxy parameter is passed, it will use the active representation, rather than the active source.

paraview.simple.GetRepresentations()

Returns all available representation proxies (display properties) in all views.

Returns

dictionary of representations. Keys are tuples consisting of the registration name and integer ID of the representation proxy, and values are the representation proxies themselves.

Return type

dict

paraview.simple.GetScalarBar(ctf, view=None)

Returns the scalar bar for the given color transfer function in the given view.

Parameters

• ctf (Color transfer function proxy.) – The color transfer function proxy whose scalar bar representation should be returned.

• view (View proxy.) – View from which the scalar bar proxy should be retrieved. Optional, defaults to the active view, if possible.

Returns

The scalar bar proxy for the color transfer function if found. his will either return an existing scalar bar or create a new one.

Return type

Scalar bar proxy

paraview.simple.GetSettingsProxy(type)

Given a string giving the type of settings to access, returns the proxy for those settings.

Parameters

type (str) – The type of settings to access. Valid types may be found by calling GetAllSettings().

paraview.simple.GetSources()

Get all available pipeline sources.

Returns

dictionary of pipeline sources. Keys are tuples consisting of the registration name and integer ID of the proxy, and values are the pipeline sources themselves.

Return type

dictionary

paraview.simple.GetTimeKeeper()

Returns the timekeeper proxy for the active session. Timekeeper is often used to manage time step information known to the ParaView application.

Returns

timekeeper

Return type

paraview.servermanager.TimeKeeper

paraview.simple.GetTimeTrack()

Returns the animation track used to control the time requested from all sources during playback

Returns

The time animation track.

Return type

paraview.servermanager.TimeAnimationCue

paraview.simple.GetTransferFunction2D(arrayname, array2name=None, representation=None, separate=False, **params)

Get the 2D color transfer function used to map a data array with the given name to colors.

Parameters

• arrayname (str) – Name of the first array whose color transfer function is requested.

• array2name (str) – Name of the second array whose color transfer function is requested.

• representation (Representation proxy.) – Used to modify the array name when using a separate color transfer function. Optional, defaults to the active representation.

• separate (bool) – If True, used to recover the separate color transfer function even if it is not used currently by the representation. Optional, defaults to False.

Returns

This may create a new 2D color transfer function if none exists, or return an existing one if found.

Return type

2D color transfer function proxy

paraview.simple.GetViewForLight(proxy)

Given a light proxy, find which view it belongs to

Parameters

proxy (Light proxy) – The light proxy whose view you want to retrieve.

Returns

The view associated with the light if found, otherwise None

Return type

View proxy or None

paraview.simple.GetViewProperties(view=None)

Same as GetActiveView(). this API is provided just for consistency with GetDisplayProperties().

paraview.simple.GetViewProperty(*arguments, **keywords)

Same as GetProperty(), except that if no ‘proxy’ parameter is passed, it will use the active view properties, rather than the active source.

paraview.simple.GetViews(viewtype=None)

Returns all views in a list.

Parameters

viewtype (str) – If provided, only the views of the specified type are returned. Optional, defaults to None.

Returns

list of views of the given viewtype, or all views if viewtype is None.

Return type

list of view proxies

paraview.simple.GetViewsInLayout(layout=None)

Returns a list of views in the given layout.

Parameters

layout (Layout proxy.) – Layout whose views should be returned. Optional, defaults to the layout for the active view, if possible.

Returns

List of views in the layout.

Return type

list

paraview.simple.GhostCells(*input, **params)

Generate ghost cells and ghost points in a composite data set. Ghosts are exchanged between blocks / partitions of same type. Currently, vtkImageData, vtkRectilinearGrid, vtkStructuredGrid, vtkPolyData, vtkUnstructuredGrid and vtkHyperTreeGrid are supported. Those input types (exception for vtkHyperTreeGrid) can be dispatched in vtkPartitionedDataSet or vtkPartitionedDataSetCollection. Inside a collection, 2 partitioned data sets do not exchange ghosts, but partitions inside a partitioned data set do.

paraview.simple.GhostCellsGenerator(*input, **params)

GhostCellsGenerator is a deprecated proxy. It will be automatically replaced by GhostCells

paraview.simple.GlobalIDSelectionSource(*input, **params)

GlobalIDSelectionSource is a source producing a global ID based selection.

paraview.simple.GlobalPointAndCellIds(*input, **params)

Generate global point and cell ids. Global ids are unique ids where the same point (or cell) will be assigned the same id even if the point (or cell) is duplicated among multiple blocks or ranks. This filter also flags duplicated points as ghost points. Note that if the input is an HyperTree Grid, this filter only generates global cell ids.

paraview.simple.Glyph(*input, **params)

The Glyph filter generates a glyph (i.e., an arrow, cone, cube, cylinder, line, sphere, or 2D glyph) at each point or cell in the input dataset. The glyphs can be oriented and scaled by the input scalar and vector arrays. If the arrays are point-centered, glyphs are placed at points in the input dataset. If the arrays are cell-centered, glyphs are placed at the center of cells in the input dataset. A transform that applies to the glyph source can be modified to change the shape of the glyph. This filter operates on any type of data set. Its output is a polygonal dataset.

To use this filter, select the Orientation Array to orient the glyphs and the Scale Array to control glyph scaling if desired - each array can be set to ‘No array’ if orientation or scaling is not desired. When scaling by a 3-element vector array, the Vector Scale Mode can be set to either ‘Scale by Magnitude’, which scales glyphs according to the vector magnitude, or ‘Scale by Components’, which treats each component as a separate scaling factor in the corresponding dimension, i.e., the first component is the scaling factor in the x-dimension, the second component scales the y-dimension, and the third component scales the z-dimension. An overall constant Scale Factor is applied following the scaling controlled by other properties of this filter.

The Glyph Mode property controls which points in the input dataset are selected for glyphing since in most cases, glyphing all points in the input dataset can be both performance impeding as well as visually cluttered.

paraview.simple.GlyphWithCustomSource(*input, **params)

The Glyph With Custom Source filter generates a glyph specified as the Source input to this filter at each point in the input dataset. The glyphs can be oriented and scaled by the input scalar and vector arrays. If the arrays are point-centered, glyphs are placed at points in the input dataset. If the arrays are cell-centered, glyphs are placed at the center of cells in the input dataset. A transform that applies to the glyph source can be modified to change the shape of the glyph. This filter operates on any type of data set. Its output is a polygonal dataset.

To use this filter, select the Orientation Array to orient the glyphs and the Scale Array to control glyph scaling if desired - each array can be set to ‘No array’ if orientation or scaling is not desired. When scaling by a 3-element vector array, the Vector Scale Mode can be set to either ‘Scale by Magnitude’, which scales glyphs according to the vector magnitude, or ‘Scale by Components’, which treats each component as a separate scaling factor in the corresponding dimension, i.e., the first component is the scaling factor in the x-dimension, the second component scales the y-dimension, and the third component scales the z-dimension. An overall constant Scale Factor is applied following the scaling controlled by other properties of this filter.

The Glyph Mode property controls which points in the input dataset are selected for glyphing since in most cases, glyphing all points in the input dataset can be both performance impeding as well as visually cluttered.

paraview.simple.Gradient(*input, **params)

The Gradient filter estimates the gradient vector at each point or cell. It operates on any type of vtkDataSet, and the output is of the same type as the input. For unstructured grids, the gradient is computed with the cell derivatives. For structured grids, the gradient is computed using central differencing, except on the boundary of the dataset where forward and backward differencing is used for the boundary elements. If the dataset is a vtkImageData, the gradient computation at the boundaries can also be done with central differencing using a duplication of the boundary values, smoothing out the result (see ‘Boundary Method’ property).

paraview.simple.GradientMagnitude(*input, **params)

The Gradient

Magnitude filter computes the magnitude of the gradient vector at each point in an image or volume. This filter operates on uniform rectilinear (image) data and produces image data output.

paraview.simple.GroupDatasets(*input, **params)

Groups multiple datasets to create a multiblock dataset

paraview.simple.GroupTimeSteps(*input, **params)

Groups all the time steps in the input into a collection with no time information. Each timestep will become one block of the output.

paraview.simple.H5PartReader(*input, **params)

Reader for H5Part (HDF5) particle files.

paraview.simple.HDF5RageReader(*input, **params)

paraview.simple.HDRReader(*input, **params)

An HDR image is a high-bit–depth image (normally 32 bits per channel) that contains color and brightness information across a very wide dynamic range.

paraview.simple.Hide(proxy=None, view=None)

Turns the visibility of a given pipeline source off in the given view. If pipeline object and/or view are not specified, active objects are used.

Parameters

• proxy (Pipeline source proxy to hide.) – The pipeline source. Optional, defaults to the active source.

• view (View proxy.) – The view in which the pipeline source should be hidden. Optional, defaults to the active view.

paraview.simple.HideAll(view=None)

Hide all pipeline sources in the given view.

Parameters

view (View proxy.) – The view in which to hide all pipeline sources. Optional, defaults to the active view.

paraview.simple.HideInteractiveWidgets(proxy=None)

If possible in the current environment, this function will request the application to hide the interactive widget(s) for the given proxy.

Parameters

proxy (Source proxy.) – The proxy whose associated interactive widgets should be hidden. Optional, if not provided the active source’s widgets are hidden.

paraview.simple.HideScalarBarIfNotNeeded(lut, view=None)

Hides the given scalar bar if it is not used by any of the displayed data.

Parameters

• lut (Scalar bar proxy) – The lookup table (lut) or scalar bar proxy

• view – The view in which the scalar bar should be hidden. Optional, defaults to hiding scalar bars in the active view.

paraview.simple.HideUnusedScalarBars(view=None)

Hides all unused scalar bars from the view. A scalar bar is used if some data is shown in that view that is coloring using the transfer function shown by the scalar bar.

Parameters

view (View proxy) – View in which unused scalar bars should be hidden. Optional, defaults to the active view.

paraview.simple.HierarchicalDataIDSelectionSource(*input, **params)

HierarchicalDataIDSelectionSource used to create an ID based selection for HierarchicalBox datasets.

paraview.simple.HierarchicalFractal(*input, **params)

The Hierarchical Fractal

source is a collection of uniform grids. All have the same dimensions. Each block has a different origin and spacing. This source uses the Mandelbrot source to create cell data. The fractal array is scaled to look like a volume fraction.

paraview.simple.Histogram(*input, **params)

paraview.simple.Histogram2D(*input, **params)

paraview.simple.HoudiniWriter(*input, **params)

Writer to write polygonal data in ASCII Houdini .geo (pre-v12.0) format.

paraview.simple.HyperTreeGrid(*input, **params)

This source uses input parameters,

most notably a string descriptor, to generate a vtkHyperTreeGrid instance representing the corresponding a tree-based AMR grid with arbitrary rectilinear geometry and either binary or ternary subdivision.

paraview.simple.HyperTreeGridAxisReflection(*input, **params)

HyperTreeGridAxisReflection is a deprecated proxy. It will be automatically replaced by AxisAlignedReflectionFilter

paraview.simple.HyperTreeGridCellCenters(*input, **params)

HyperTreeGridCellCenters is a deprecated proxy. It will be automatically replaced by CellCenters

paraview.simple.HyperTreeGridDepthLimiter(*input, **params)

Extract all levels down to a specified depth from a hyper tree grid. If the required depth is greater or equal to the maximum level of the input grid, then the output is identical. Note that when a material mask is present, the geometry extent of the output grid is guaranteed to contain that of the input tree, but the former might be strictly larger than the latter. This is not a bug but an expected behavior of which the user should be aware.

paraview.simple.HyperTreeGridEvaluateCoarse(*input, **params)

This filter evaluates the value of each coarse cell from the values ​​assigned to its children according to different calculation methods (Min, Max, Sum, Average, Elder Child, etc).

paraview.simple.HyperTreeGridFeatureEdgesFilter(*input, **params)

HyperTreeGridFeatureEdgesFilter is a deprecated proxy. It will be automatically replaced by FeatureEdges

paraview.simple.HyperTreeGridGeometryFilter(*input, **params)

Generate PolyData representing the external surface of a HTG.

paraview.simple.HyperTreeGridGhostCellsGenerator(*input, **params)

HyperTreeGridGhostCellsGenerator is a deprecated proxy. It will be automatically replaced by GhostCells

paraview.simple.HyperTreeGridRandom(*input, **params)

This source uses input parameters,

most notably a seed value, to generate a vtkHyperTreeGrid instance for testing.

paraview.simple.HyperTreeGridReader(*input, **params)

Reads HyperTreeGrid data files

paraview.simple.HyperTreeGridToDualGrid(*input, **params)

This filter converts vtkHyperTreeGrid data to vtkUnstructuredGrid, using the dual grid. The converted output consumes much more memory but is compatible with most of the standard filters.

paraview.simple.HyperTreeGridToUnstructuredGrid(*input, **params)

This filter converts vtkHyperTreeGrid data to vtkUnstructuredGrid. The converted output consumes much more memory but is compatible with most of the standard filters.

paraview.simple.HyperTreeGridVisibleLeavesSize(*input, **params)

Create 2 new cell fields. The first one, named ‘ValidCell’ by default, has a value of 1.0 for leaf (non-refined) cells that are neither masked nor ghost, and 0.0 otherwise. The second one, named ‘CellSize’ by default, is set to the size (volume) of the cell for 3D HTGs. This field has a value for every cell traversed through the cursor, valid or not. By extension, CellSize is set to the cell area for 2D HTG and cell length for 1D.

paraview.simple.HyperTreeGridWriter(*input, **params)

Writer to write hypertree data as a HyperTreeGrid file.

paraview.simple.IDSelectionSource(*input, **params)

IDSelectionSource is a source producing a ID based selection. This cannot be used for selecting composite datasets.

paraview.simple.IOSSCellGridReader(*input, **params)

Reader for IOSS supported data that generates cell grids. This is a distributed reader.

paraview.simple.IOSSReader(*input, **params)

Reader for IOSS supported data. This is a distributed reader.

paraview.simple.IOSSWriter(*input, **params)

Write Exodus files using IOSS library.

paraview.simple.ImageDataToAMR(*input, **params)

paraview.simple.ImageDataToUniformGrid(*input, **params)

Create a vtkUniformGrid from a vtkImageData by passing in arrays to be used for point and/or cell blanking. By default, values of 0 in the specified array will result in a point or cell being blanked. Use Reverse to switch this.

paraview.simple.ImageDatatoPointSet(*input, **params)

The Image

Data to Point Set filter takes an image data (uniform rectilinear grid) object and outputs an equivalent structured grid, which is a type of point set. This brings the data to a broader category of data storage but only adds a small amount of overhead. This filter can be helpful in applying filters that expect or manipulate point coordinates.

paraview.simple.ImageReader(*input, **params)

The raw series

reader reads raw files. The output is a time sequence of uniform rectilinear (image/volume) dataset. The default file extension is .raw.

paraview.simple.ImageShrink(*input, **params)

The Image Shrink

filter reduces the size of an image/volume dataset by subsampling it (i.e., extracting every nth pixel/voxel in integer multiples). The subsampling rate can be set separately for each dimension of the image/volume.

paraview.simple.ImportPresets(filename, location=16)

Import presets from a file. The file can be in the legacy color map XML format or in the new JSON format.

Parameters

• filename (str) – Path of the file containing the presets.

• location (vtkPVServer.ServerFlags enum value) – Where the statefile should be save, e.g., pass vtkPVSession.CLIENT if the statefile is located on the client system (default value), pass in vtkPVSession.SERVERS if on the server. Optional, defaults to vtkPVSession.CLIENT.

Returns

True on success, False otherwise.

paraview.simple.ImportView(filename, view=None, **params)

Import a view from a specified input scene file.

Parameters

• filename (str) – The name of the file to import.

• view (View proxy.) – View proxy into which the scene should be imported. Optional, defaults to the active view.

• params – A variadic list of key=value pairs giving values of specific named properties of the importer.

paraview.simple.InSituParticlePath(*input, **params)

The Particle Trace filter generates pathlines in a vector field from a collection of seed points. The vector field used is selected from the Vectors menu, so the input data set is required to have point-centered vectors. The Seed portion of the interface allows you to select whether the seed points for this integration lie in a point cloud or along a line. Depending on which is selected, the appropriate 3D widget (point or line widget) is displayed along with traditional user interface controls for positioning the point cloud or line within the data set. Instructions for using the 3D widgets and the corresponding manual controls can be found in section 7.4. This filter operates on any type of data set, provided it has point-centered vectors. The output is polygonal data containing polylines. This filter is available on the Toolbar.

paraview.simple.IntegrateVariables(*input, **params)

The Integrate Attributes filter integrates all point and cell data attributes while computing the total length, area or volume. This filter does not integrate point and cell data for 0-D cells (vertex and polyvertex). If the input dataset has mixed dimensionality, only the cells of highest dimension will be used for integration. Ex: In a dataset with lines, triangles and hexahedra, the integration process will ignore contribution from lines and triangles. When the highest dimension is 1, the sum variable corresponds to the total length. Similarly, for 2-D and 3-D integration the sum variable is the total area and total volume respectively. The output of this filter is a single point and vertex. The attributes for this point and vertex will contain the integration results for the corresponding input attributes and the sum variable.

paraview.simple.Interact(view=None)

Call this method to start interacting with a view. This method will block until the interaction is done. If the local process cannot support interactions, this method will simply return without doing anything.

Parameters

view (View proxy.) – The interaction occurs with this view. Optional, defaults to the active view.

paraview.simple.InterpolatetoQuadraturePoints(*input, **params)

Create scalar/vector data arrays interpolated to quadrature points.

paraview.simple.IntersectFragments(*input, **params)

The Intersect Fragments filter perform geometric intersections on sets of fragments. The filter takes two inputs, the first containing fragment geometry and the second containing fragment centers. The filter has two outputs. The first is geometry that results from the intersection. The second is a set of points that is an approximation of the center of where each fragment has been intersected.

paraview.simple.IsoVolume(*input, **params)

This filter clip away the cells using lower and upper thresholds.

paraview.simple.JPEGSeriesReader(*input, **params)

The JPEG series

reader reads JPEG files. The output is a time sequence of uniform rectilinear (image/volume) dataset. The default file extension is .jpg or .jpeg.

paraview.simple.JPEGWriter(*input, **params)

Writer to write image data as a JPEG file. It supports 1 to 3 component data of unsigned char or unsigned short. This Writer can also generate a stack of images when the FileName is in the form of /path/file_%03d.jpg and that the input data is a 3D image data.

paraview.simple.JSONImageWriter(*input, **params)

paraview.simple.KMeans(*input, **params)

This filter either computes a statistical model of a dataset or takes such a model as its second input. Then, the model (however it is obtained) may optionally be used to assess the input dataset.<p> This filter iteratively computes the center of k clusters in a space whose coordinates are specified by the arrays you select. The clusters are chosen as local minima of the sum of square Euclidean distances from each point to its nearest cluster center. The model is then a set of cluster centers. Data is assessed by assigning a cluster center and distance to the cluster to each point in the input data set.

paraview.simple.KeyFrame(*input, **params)

paraview.simple.KeyFrameAnimationCue(*input, **params)

Animation cue with keyframes.

paraview.simple.LSDynaReader(*input, **params)

This reader

reads LS-Dyna databases. This is a distributed reader.

paraview.simple.LegacyParticlePath(*input, **params)

The Particle Trace filter generates pathlines in a vector field from a collection of seed points. The vector field used is selected from the Vectors menu, so the input data set is required to have point-centered vectors. The Seed portion of the interface allows you to select whether the seed points for this integration lie in a point cloud or along a line. Depending on which is selected, the appropriate 3D widget (point or line widget) is displayed along with traditional user interface controls for positioning the point cloud or line within the data set. Instructions for using the 3D widgets and the corresponding manual controls can be found in section 7.4. This filter operates on any type of data set, provided it has point-centered vectors. The output is polygonal data containing polylines.

paraview.simple.LegacyStreakLine(*input, **params)

The Particle Trace filter generates pathlines in a vector field from a collection of seed points. The vector field used is selected from the Vectors menu, so the input data set is required to have point-centered vectors. The Seed portion of the interface allows you to select whether the seed points for this integration lie in a point cloud or along a line. Depending on which is selected, the appropriate 3D widget (point or line widget) is displayed along with traditional user interface controls for positioning the point cloud or line within the data set. Instructions for using the 3D widgets and the corresponding manual controls can be found in section 7.4. This filter operates on any type of data set, provided it has point-centered vectors. The output is polygonal data containing polylines.

paraview.simple.LegacyVTKReader(*input, **params)

The Legacy VTK reader

loads files stored in VTK’s legacy file format (before VTK 4.2, although still supported). The expected file extension is .vtk. The type of the dataset may be structured grid, uniform rectilinear grid (image/volume), non-uniform rectilinear grid, unstructured grid, or polygonal. This reader also supports file series.

paraview.simple.LevelScalarsOverlappingAMR(*input, **params)

LevelScalarsOverlappingAMR is a deprecated proxy. It will be automatically replaced by OverlappingAMRLevelIds

paraview.simple.Line(*input, **params)

The Line

source can be used to interactively (using a 3D widget) or manually (using the entries on the user interface) add a line to the 3D scene. The output of the Line source is polygonal data.

paraview.simple.LinearCellExtrusion(*input, **params)

The Linear

Extrusion filter creates a swept surface by translating the input dataset along the cell normals or a specified vector. This filter is intended to operate on polygonal data and produces 3D unstructured grid output.

paraview.simple.LinearExtrusion(*input, **params)

The Linear

Extrusion filter creates a swept surface by translating the input dataset along a specified vector. This filter is intended to operate on 2D polygonal data. This filter operates on polygonal data and produces polygonal data output.

paraview.simple.ListColorPresetNames()

Returns a list containing the currently available color transfer function preset names.

Returns

List of currently available transfer function preset names.

Return type

List of str

paraview.simple.LiveProgrammableSource(*input, **params)

A programmable source that can produce new data autonomously.

paraview.simple.LoadCustomFilters(filename, ns=None)

Loads a custom filter XML file and updates this module with new constructors if any. If you loaded the simple module with from paraview.simple import *, make sure to pass globals() as an argument.

Parameters

• filename (str) – Path to XML file with custom filter definitions.

• ns (dict) – Namespace in which new functions will be loaded. Optional, defaults to None.

paraview.simple.LoadDistributedPlugin(pluginname, remote=True, ns=None)

Loads a plugin that’s distributed with the ParaView executable. This uses the information known about plugins distributed with ParaView to locate the shared library for the plugin to load.

Parameters

• pluginname (str) – Short name of the plugin (not a file path)

• remote (bool) – If True, loads the plugin on the server unless the connection is not remote. If False, loads the plugin on the client. Optional, defaults to True.

• ns (dict) – Namespace in which new functions will be loaded. Optional, defaults to None.

Raises

RuntimeError – If the plugin was not found.

paraview.simple.LoadLookupTable(fileName)

Load transfer function preset from a file. Both JSON (new) and XML (legacy) preset formats are supported.

Parameters

fileName (str) – If the filename ends with a .xml, it’s assumed to be a legacy color map XML and will be converted to the new format before processing.

Returns

True if successful, False otherwise.

Return type

bool

paraview.simple.LoadPalette(paletteName)

Load a color palette to override the default foreground and background colors used by ParaView views. The current global palette’s colors are set to the colors in the loaded palette.

Parameters

paletteName (str) – Name of the palette to load from this list: ‘WarmGrayBackground’, ‘DarkGrayBackground’, ‘NeutralGrayBackground’, ‘LightGrayBackground’, ‘WhiteBackground’, ‘BlackBackground’, ‘GradientBackground’.

paraview.simple.LoadPlugin(filename, remote=True, ns=None)

Loads a ParaView plugin and updates this module with new constructors if any. The remote argument (default to True) is to specify whether the plugin will be loaded on the client (remote=False) or on the server (remote=True).

If you loaded the simple module with from paraview.simple import *, make sure to pass globals() as an argument:

LoadPlugin("myplugin", False, globals()) # to load on client
LoadPlugin("myplugin", True, globals())  # to load on server
LoadPlugin("myplugin", ns=globals())     # to load on server

Otherwise, the new functions will not appear in the global namespace.

Parameters

• filename (str) – Path to the plugin to load.

• remote (bool) – If True, loads the plugin on the server unless the connection is not remote. If False, loads the plugin on the client. Optional, defaults to True.

• ns (dict) – Namespace in which new functions will be loaded. Optional, defaults to None.

Returns

None

paraview.simple.LoadPlugins(*args, **kwargs)

Loads ParaView plugins and updates this module with new constructors if any. The remote keyword argument (default to True) is to specify whether the plugin will be loaded on client (remote=False) or on server (remote=True). Proxy definition updates are deferred until all plugins have been read, which can be more computationally efficient when multiple plugins are loaded in sequence.

If you loaded the simple module with from paraview.simple import *, make sure to pass globals() as a keyword argument:

LoadPlugins("myplugin1", "myplugin2", remote=False, ns=globals()) # to load on client
LoadPlugins("myplugin", "myplugin2", remote=True, ns=globals())  # to load on server
LoadPlugins("myplugin", "myplugin2", ns=globals())     # to load on server

Otherwise, the new functions will not appear in the global namespace.

Note, remote=True has no effect when the connection is not remote.

paraview.simple.LoadState(statefile, data_directory=None, restrict_to_data_directory=False, filenames=None, location=16, *args, **kwargs)

Load PVSM state file.

This will load the state specified in the statefile.

ParaView can update absolute paths for data files used in the state which can be useful to portably load state file across different systems.

Alternatively, filenames can be used to specify a list of filenames explicitly. This must be list of the following form:

[
    {
        # either 'name' or 'id' are required. if both are provided, 'id'
        # is checked first.
        "name" : "[reader name shown in pipeline browser]",
        "id"   : "[reader id used in the pvsm state file]",

        # all modified filename-like properties on this reader
        "FileName" : ...
        ....
    },

    ...
]

Calling this function with other positional or keyword arguments will invoke the legacy signature of this function _LoadStateLegacy.

Parameters

• statefile (str) – Path to the statefile to load

• data_directory (str) – If not None, then ParaView searches for files matching those used in the state under the specified directory and if found, replaces the state to use the found files instead. Optional, defaults to None.

• restrict_to_data_directory (bool) – If set to True, if a file is not found under the data_directory, it will raise an error, otherwise it is left unchanged. Optional, defaults to False.

• filenames (str) – JSON-formatted string to specify a list of filenames.

• location (vtkPVServer.ServerFlags enum value) – Where the statefile is located, e.g., pass vtkPVSession.CLIENT if the statefile is located on the client system (default value), pass in vtkPVSession.SERVERS if on the server. Optional, defaults to client.

paraview.simple.LoadXML(xmlstring, ns=None)

Given a server manager XML as a string, parse and process it. If you loaded the simple module with from paraview.simple import *, make sure to pass globals() as the second arguments:

LoadXML(xmlstring, globals())

Otherwise, the new functions will not appear in the global namespace.

Parameters

• xmlstring (str) – XML string containing server manager definitions.

• ns (dict) – Namespace in which new functions will be defined. Optional, defaults to None.

paraview.simple.LocateView(displayProperties=None)

Returns the view associated with the given displayProperties/representation object if it exists.

Parameters

displayProperties (representation proxy) – a representation proxy returned by GetRepresentation(), GetDisplayProperties(), or Show() functions. Optional, defaults to the active representation.

Returns

The view associated with the representation if it exists, otherwise None

Return type

View proxy or None

paraview.simple.LocationSelectionSource(*input, **params)

LocationSelectionSource is used to create a location based selection.

paraview.simple.Logo(*input, **params)

paraview.simple.LoopSubdivision(*input, **params)

The Loop Subdivision filter increases the granularity of a polygonal mesh. It works by dividing each triangle in the input into four new triangles. It is named for Charles Loop, the person who devised this subdivision scheme. This filter only operates on triangles, so a data set that contains other types of polygons should be passed through the Triangulate filter before applying this filter to it. This filter only operates on polygonal data (specifically triangle meshes), and it produces polygonal output.

paraview.simple.MFIXReader(*input, **params)

vtkMFIXReader creates an unstructured grid dataset. It reads a restart file and a set of sp files. The restart file contains the mesh information. MFIX meshes are either cylindrical or rectilinear, but this reader will convert them to an unstructured grid. The sp files contain transient data for the cells. Each sp file has one or more variables stored inside it.

paraview.simple.MPIMoveData(*input, **params)

paraview.simple.MRCSeriesReader(*input, **params)

The MRC series

reader reads MRC files. The output is a time sequence of uniform rectilinear (image/volume) dataset. The default file extension is .mrc but .ali, .st and .rec are also recognized.

paraview.simple.MakeBlueToRedLT(min, max)

Create a LookupTable that go from blue to red using the scalar range provided by the min and max arguments.

Parameters

• min (float) – Minimum range value.

• max (float) – Maximum range value.

Returns

the blue-to-red lookup table

Return type

Lookup table proxy.

paraview.simple.Mandelbrot(*input, **params)

The

Mandelbrot source can be used to add a uniform rectilinear grid with scalar values derived from the Mandelbrot set to the 3D scene. The equation used is z = z^2 + C (where z and C are complex, and C is a constant). The scalar values in the grid are the number of iterations of the equation it takes for the magnitude of the value to become greater than 2. In the equation, the initial value of z is 0. By default, the real component of C is mapped onto the X axis; the imaginary component of C is mapped onto the Y axis; and the imaginary component of the initial value is mapped onto the Z axis. If a two-dimensional extent is specified, the resulting image will be displayed. If a three-dimensional extent is used, then the bounding box of the volume will be displayed. The output of the Mandelbrot source is image (uniform rectilinear) data.

paraview.simple.MaskPoints(*input, **params)

The Mask Points filter reduces the number of points in the dataset. It operates on any type of dataset, but produces only points / vertices as output.

paraview.simple.MaterialInterfaceFilter(*input, **params)

The Material Interface filter finds voxels inside of which a material fraction (or normalized amount of material) is higher than a given threshold. As these voxels are identified surfaces enclosing adjacent voxels above the threshold are generated. The resulting volume and its surface are what we call a fragment. The filter has the ability to compute various volumetric attributes such as fragment volume, mass, center of mass as well as volume and mass weighted averages for any of the fields present. Any field selected for such computation will be also be copied into the fragment surface’s point data for visualization. The filter also has the ability to generate Oriented Bounding Boxes (OBB) for each fragment. The data generated by the filter is organized in three outputs. The “geometry” output, containing the fragment surfaces. The “statistics” output, containing a point set of the centers of mass. The “obb representation” output, containing OBB representations (poly data). All computed attributes are copied into the statistics and geometry output. The obb representation output is used for validation and debugging purposes and is turned off by default. To measure the size of craters, the filter can invert a volume fraction and clip the volume fraction with a sphere and/or a plane.

paraview.simple.Median(*input, **params)

The Median filter operates on uniform rectilinear (image or volume) data and produces uniform rectilinear output. It replaces the scalar value at each pixel / voxel with the median scalar value in the specified surrounding neighborhood. Since the median operation removes outliers, this filter is useful for removing high-intensity, low-probability noise (shot noise).

paraview.simple.MergeBlocks(*input, **params)

Merge Blocks appends all vtkDataSet leaves of the input composite dataset to a single unstructured grid (or polydata if all leaves are polydata). The subtree to be combined can be chosen using the SubTreeCompositeIndex. If the SubTreeCompositeIndex is a leaf node, then no appending is required nor performed.

paraview.simple.MergeTime(*input, **params)

Merge all inputs timestep list. Remove duplicate using a Tolerance, either absolute or relative. The resulting timesteps list can be an union or an

intersection of the inputs ones.

paraview.simple.MergeVectorComponents(*input, **params)

The MergeVectorComponents filter can be used to merge 1-component arrays of the same attribute type (point-data or cell-data) into one 3-component vector.

paraview.simple.MeshQuality(*input, **params)

This filter creates a new cell array containing a geometric measure of each cell’s fitness. Different quality measures can be chosen for different cell shapes. Supported shapes include linear triangles, quadrilaterals, tetrahedra, pyramids, wedges, and hexahedra. For other shapes, a value of 0 is assigned.

paraview.simple.MetaFileSeriesReader(*input, **params)

Read a series

of meta images. The file extension is .mhd

paraview.simple.MetaImageWriter(*input, **params)

Writer to

write a binary UNC meta image data. This is a fairly simple yet powerful format consisting of a text header and a binary data section. MetaImage headers are expected to have extension: “.mha” or “.mhd”

paraview.simple.MinMax(*input, **params)

paraview.simple.MoleculeToLines(*input, **params)

Convert a molecule into lines. Each atom of the input becomes a point of the output polydata, each bond a line.

paraview.simple.MulticorrelativeStatistics(*input, **params)

This filter either computes a statistical model of a dataset or takes such a model as its second input. Then, the model (however it is obtained) may optionally be used to assess the input dataset.<p> This filter computes the covariance matrix for all the arrays you select plus the mean of each array. The model is thus a multivariate Gaussian distribution with the mean vector and variances provided. Data is assessed using this model by computing the Mahalanobis distance for each input point. This distance will always be positive.<p> The learned model output format is rather dense and can be confusing, so it is discussed here. The first filter output is a multiblock dataset consisting of 2 tables: <ol> <li> Raw covariance data. <li> Covariance matrix and its Cholesky decomposition. </ol> The raw covariance table has 3 meaningful columns: 2 titled “Column1” and “Column2” whose entries generally refer to the N arrays you selected when preparing the filter and 1 column titled “Entries” that contains numeric values. The first row will always contain the number of observations in the statistical analysis. The next N rows contain the mean for each of the N arrays you selected. The remaining rows contain covariances of pairs of arrays.<p> The second table (covariance matrix and Cholesky decomposition) contains information derived from the raw covariance data of the first table. The first N rows of the first column contain the name of one array you selected for analysis. These rows are followed by a single entry labeled “Cholesky” for a total of N+1 rows. The second column, Mean contains the mean of each variable in the first N entries and the number of observations processed in the final (N+1) row.<p> The remaining columns (there are N, one for each array) contain 2 matrices in triangular format. The upper right triangle contains the covariance matrix (which is symmetric, so its lower triangle may be inferred). The lower left triangle contains the Cholesky decomposition of the covariance matrix (which is triangular, so its upper triangle is zero). Because the diagonal must be stored for both matrices, an additional row is required — hence the N+1 rows and the final entry of the column named “Column”.

paraview.simple.Nek5000Reader(*input, **params)

The Nek5000 reader

reads Nek5000 data files and outputs an unstructured grid dataset. This is a distributed reader.

paraview.simple.NetCDFCAMreader(*input, **params)

This reader reads in unstructured grid data from a NetCDF file. The grid data is in a set of planes as quadrilateral cells. The reader creates hex cells in order to create a volumetric grid.

paraview.simple.NetCDFMPASreader(*input, **params)

This reader reads unstructured grid MPAS data from a file. It creates a dual grid It assumes the grid is in the global domain. By default, it creates a spherical view of vertical layer 0. It assumes it is ocean data. It gives several options to change the view to multilayer (all vertical layers will have a thickness determined by the value in the slider), lat/lon projection or atmospheric (vertical layers go out away from the center of the sphere, instead of down towards the center as they do for ocean data). It doesn’t handle data in the rectangular domain. This is not a parallel reader. It expects one .nc file of data. It can display cell or vertex-centered data, but not edge data. When converted to the dual grid, cell-centered data becomes vertex-centered and vice-versa. NOTES: When using this reader, it is important that you remember to do the following: 1. When changing a selected variable, remember to select it also in the drop down box to color by. It doesn’t color by that variable automatically 2. When selecting multilayer sphere view, start with layer thickness around 100,000 3. When selecting multilayer lat/lon view, start with layer thickness around 10 4. Always click the -Z orientation after making a switch from lat/lon to sphere, from single to multilayer or changing thickness. 5. Be conservative on the number of changes you make before hitting Apply, since there may be bugs in this reader. Just make one change and then hit Apply. For problems, contact Christine Ahrens (cahrens@lanl.gov)

paraview.simple.NetCDFPOPreader(*input, **params)

The reader reads regular rectilinear grid (image/volume) data from a NetCDF file.

paraview.simple.NetCDFReader(*input, **params)

Reads

arrays from NetCDF files into structured VTK data sets. In the absence of any other information, the files will be read as image data. This reader will also look for meta information specified by the CF convention that specify things like topology and time. This information can cause the output to be a nonuniform rectilinear grid or curvilinear (structured) grid. Details on the CF convention can be found at http://cf-pcmdi.llnl.gov/. It should be noted that the CF convention is a superset of the COARDS convention, so COARDS conventions will also be recognized.

paraview.simple.NetCDFUGRIDreader(*input, **params)

paraview.simple.NetworkImageSource(*input, **params)

paraview.simple.NormalGlyphs(*input, **params)

Filter

computing surface normals.

paraview.simple.NrrdReader(*input, **params)

The

Nrrd reader reads raw image data much like the Raw Image Reader except that it will also read metadata information in the Nrrd format. This means that the reader will automatically set information like file dimensions. There are several limitations on what type of nrrd files we can read. This reader only supports nrrd files in raw format. Other encodings like ascii and hex will result in errors. When reading in detached headers, this only supports reading one file that is detached.

paraview.simple.OMETIFFChannelCalculator(*input, **params)

paraview.simple.OMETIFFReader(*input, **params)

Supports reading OME-TIFF files.

paraview.simple.OMFReader(*input, **params)

Reader for OMF (Open Mining Format) files.

paraview.simple.ObjectFileFormatOFFReader(*input, **params)

The OFF reader

reads data stored in Object File Format .OFF format. The expected file extension is .off, the datasets resulting from reading these files are polygons.

paraview.simple.OctreeImagetoPointSet(*input, **params)

OctreeImageToPointSet can be used to convert an image with an unsigned char octree cell array to a point set. Each bit of the unsigned char indicates if the cell had a point close to one of its 8 corners. It can optionally also output a point array based on an input cell array. This array will have 1 of the components of the input array.

paraview.simple.OpenDataFile(filename, **extraArgs)

Creates a reader to read the give file, if possible. This uses extension matching to determine the best reader possible.

Returns

Returns a suitable reader if found. If a reader cannot be identified, then this returns None.

Return type

Reader proxy, or None

paraview.simple.OpenFOAMReader(*input, **params)

The OpenFOAM reader

reads OpenFOAM data files and outputs multiblock datasets. Mesh information and time dependent data are supported. This is a distributed reader. See https://www.openfoam.com/documentation/user-guide for a description of the OpenFOAM format.

paraview.simple.Outline(*input, **params)

The Outline filter generates an axis-aligned bounding box for the input dataset. This filter operates on any type of dataset and produces polygonal output.

paraview.simple.OutlineCorners(*input, **params)

The Outline Corners filter generates the corners of a bounding box for the input dataset. This filter operates on any type of dataset and produces polygonal output.

paraview.simple.OutlineCurvilinearDataSet(*input, **params)

The Outline filter

generates an outline of the outside edges of the input dataset, rather than the dataset’s bounding box. This filter operates on structured grid datasets and produces polygonal output.

paraview.simple.OutlineGenericDataSet(*input, **params)

The Generic Outline

filter generates an axis-aligned bounding box for the input data set. The Input menu specifies the data set for which to create a bounding box. This filter operates on generic data sets and produces polygonal output.

paraview.simple.OutlineSource(*input, **params)

The Outline

source creates an axis aligned bounding box given the user-specified minimum and maximum coordinates for each axis.

paraview.simple.OutputPort(proxy, outputPort=0)

paraview.simple.OverlappingAMRLevelIds(*input, **params)

The Level

Scalars filter uses colors to show levels of a hierarchical dataset.

paraview.simple.OverlappingCellsDetector(*input, **params)

Generates overlap count between cells of the input in a cell array named “NumberOfCollisionsPerCell”.

paraview.simple.PCANormalEstimation(*input, **params)

The PCANormalEstimation estimates normals of points using Principal Component Analysis. Add a PCANormals field to the output data.

paraview.simple.PDBReader(*input, **params)

The PDB reader reads files in

the format used by the Protein Data Bank (an archive of experimentally determined three-dimensional structures of biological macromolecules). The expected file extension is .pdb. The output datasets are polygonal.

paraview.simple.PDataSetWriterPolyData(*input, **params)

Writer to write vtkPolyData in a legacy vtk data file. This version is used when running in parallel. It gathers data to first node and saves one file.

paraview.simple.PDataSetWriterUnstructuredGrid(*input, **params)

Writer to write vtkUnstructuredGrid of data object in a legacy vtk data file. This version is used when running in parallel. It gathers data to first node and saves one file.

paraview.simple.PIOReader(*input, **params)

PIO is a file format

in support of XRAGE. The input file (.pio) opened by the PIO reader is an ASCII description of the data files within a dump directory numbered by cycle. The reader uses a PIOData class to read the file and a PIOAdaptor to build an unstructured or hypertree grid from the data. Requested data is filled into the structures. This is a distributed reader.

paraview.simple.PLOT3DMetaFileReader(*input, **params)

The main goal of this reader is to make it easy to read PLOT3D files, specifically time series of PLOT3D files. PLOT3D files can take many different forms based on their content. Unfortunately, it is not a self-describing format therefore the user needs to pass information about the contents of the file to the reader. Normally, this is done by setting a number of member variables. The goal of this reader is to provide a simple format that enable the writer of the PLOT3D file to describe its settings as well as group a number of files as a time series.

paraview.simple.PLOT3DReader(*input, **params)

PLOT3D is a plotting

package developed at NASA. The PLOT3D reader can read both ASCII and binary PLOT3D files. The default file extension for the geometry files is .xyz, and the default file extension for the solution files is .q. The output of this reader is a multiblock dataset containing curvilinear (structured grid) datasets. This is a distributed reader.

paraview.simple.PLYReader(*input, **params)

The PLY reader

reads files stored in the PLY polygonal file format developed at Stanford University. The PLY files that ParaView can read must have the elements “vertex” and “face” defined. The “vertex” elements must have the properties “x”, “y”, and “z”. The “face” elements must have the property “vertex_indices” defined. The default file extension for this reader is .ply.

paraview.simple.PNGSeriesReader(*input, **params)

The PNG reader reads PNG

(Portable Network Graphics) files, and the output is a uniform rectilinear (image/volume) dataset. The default file extension is .png.

paraview.simple.PNGWriter(*input, **params)

Writer to

write image data as a PNG file. It supports 1 to 4 component data of unsigned char or unsigned short. This Writer can also generate a stack of images when the FileName is in the form of /path/file_%03d.png and that the input data is a 3D image data.

paraview.simple.POBJWriter(*input, **params)

Writer to write polygonal data in Wavefront OBJ format. Written files contain the geometry including lines, triangles and polygons. Normals and texture coordinates on points are also written if they exist. This version is used when running in parallel. It gathers data to first node and saves one file.

paraview.simple.PPLYWriter(*input, **params)

Writer to write polygonal data in Stanford University PLY format. The data can be written in either binary (little or big endian) or ASCII representation. As for PointData and CellData, vtkPLYWriter cannot handle normals or vectors. It only handles RGB PointData and CellData. This version is used when running in parallel. It gathers data to first node and saves one file.

paraview.simple.PSTLWriter(*input, **params)

STLWriter

writes stereo lithography (.stl) files in either ASCII or binary form. Stereo lithography files only contain triangles. If polygons with more than 3 vertices are present, only the first 3 vertices are written. Use TriangleFilter to convert polygons to triangles. This version of the reader is used when running in parallel. It gathers all the geometry to first node and saves 1 file.

paraview.simple.PTSReader(*input, **params)

The PTS reader

reads ASCII PTS Point Cloud files containing points as well as optional intensity and color information. The default file extension is .pts. This reader produces a polydata set of a single vertex cell containing all of the points.

paraview.simple.PVDReader(*input, **params)

The PVD reader reads data

stored in ParaView’s PVD file format. The .pvd file is essentially a header file that collects together other data files stored in VTK’s XML-based file format.

paraview.simple.PVTrivialProducer(*input, **params)

paraview.simple.PVTrivialProducer2(*input, **params)

paraview.simple.ParallelNetCDFPOPreader(*input, **params)

The reader reads regular rectilinear grid (image/volume) data from a NetCDF file. Only a subset of the processes actually read the file and these processes communicate the data to other processes.

paraview.simple.ParticlePath(*input, **params)

The Particle Trace filter generates pathlines in a vector field from a collection of seed points. The vector field used is selected from the Vectors menu, so the input data set is required to have point-centered vectors. The Seed portion of the interface allows you to select whether the seed points for this integration lie in a point cloud or along a line. Depending on which is selected, the appropriate 3D widget (point or line widget) is displayed along with traditional user interface controls for positioning the point cloud or line within the data set. Instructions for using the 3D widgets and the corresponding manual controls can be found in section 7.4. This filter operates on any type of data set, provided it has point-centered vectors. The output is polygonal data containing polylines. This filter is available on the Toolbar.

paraview.simple.ParticleTracer(*input, **params)

The Particle Trace filter generates pathlines in a vector field from a collection of seed points. The vector field used is selected from the Vectors menu, so the input data set is required to have point-centered vectors. The Seed portion of the interface allows you to select whether the seed points for this integration lie in a point cloud or along a line. Depending on which is selected, the appropriate 3D widget (point or line widget) is displayed along with traditional user interface controls for positioning the point cloud or line within the data set. Instructions for using the 3D widgets and the corresponding manual controls can be found in section 7.4. This filter operates on any type of data set, provided it has point-centered vectors. The output is polygonal data containing polylines. This filter is available on the Toolbar.

paraview.simple.ParticlesReader(*input, **params)

vtkParticleReader reads

either a binary or a text file of particles. Each particle can have associated with it an optional scalar value. So the format is: x, y, z, scalar (all floats or doubles). The text file can consist of a comma delimited set of values. In most cases vtkParticleReader can automatically determine whether the file is text or binary. The data can be either float or double. Progress updates are provided. With respect to binary files, random access into the file to read pieces is supported.

paraview.simple.PartitionBalancer(*input, **params)

Evens the number of partitions across ranks, while discarding empty partitions of the input There are two ways this filter will balance the input. If Squash is selected, empty partitions are appended to ranks having less partitions than the rank with the most partitions. If Expand is selected, then the number of partitions in the output is equal to the number of partitions if all partitions were sent to one rank. For a given rank, the indices of non empty partitions in the output map to empty partitions in every other ranks.

paraview.simple.PartitionedDataSetCollectionSource(*input, **params)

This source can be used to createa vtkPartitionedDataSetCollection for testing purposes.

paraview.simple.PartitionedLegacyVTKReader(*input, **params)

The

Partitioned Legacy VTK reader loads files stored in VTK’s partitioned legacy file format (before VTK 4.2, although still supported). The expected file extension is .pvtk. The type of the dataset may be structured grid, uniform rectilinear grid (image/volume), non-uniform rectilinear grid, unstructured grid, or polygonal.

paraview.simple.PassArrays(*input, **params)

The Pass Arrays filter makes a shallow copy of the output data object from the input data object except for passing only the arrays specified to the output from the input.

paraview.simple.PassThrough(*input, **params)

A simple pass-through filter that doesn’t transform data in any way.

paraview.simple.PedigreeIDSelectionSource(*input, **params)

PedigreeIDSelectionSource is a source producing a pedigree ID based selection.

paraview.simple.PerlinNoise(*input, **params)

Generates a Perlin noise point data array according to a deterministic pseudo-random noise function based on the location of each point in the dataset.

paraview.simple.PhastaReader(*input, **params)

This Phasta reader reads files stored in the Phasta (a CFD package) format. The expected file extension is .pht. The output of this reader is a multipiece data set.

paraview.simple.Plane(*input, **params)

The Plane source can be used to add a polygonal parallelogram to the 3D scene. Unlike the sphere, cone, and cylinder sources, the parallelogram is exactly represented at the lowest resolution, but higher resolutions may be desired if this plane is to be used as an input to a filter. The output of the Plane source is polygonal data.

paraview.simple.PlotData(*input, **params)

This filter

prepares arbitrary data to be plotted in any of the plots. By default the data is shown in a XY line plot.

paraview.simple.PlotDataOverTime(*input, **params)

paraview.simple.PlotGlobalVariablesOverTime(*input, **params)

Plot global data arrays stored in the input field data over time. Global data arrays are identified as described. When connected to an Exodus reader, this filter can detect Exodus global temporal data arrays and only plot those automatically. To disable this auto-detection, turn off AutoDetectGlobalTemporalDataArrays.

paraview.simple.PlotOnIntersectionCurves(*input, **params)

Extracts the surface, intersect it with a 2D plane. Plot the resulting polylines.

paraview.simple.PlotOnSortedLines(*input, **params)

The Plot on Sorted Lines filter sorts and orders

polylines for graph visualization. See http://www.paraview.org/ParaView3/index.php/Plotting_Over_Curves for more information.

paraview.simple.PlotOverLine(*input, **params)

The Plot Over Line filter samples the dataset attributes of the

input dataset at the points of a given line. The values of the point-centered variables along that line will be displayed in an XY Plot. This filter uses interpolation to determine the values at the selected point, whether or not it lies at an input point. This filter operates on any type of data and produces a polygonal output (a polyline). One can use different sampling patterns with this filter. “Sample At Cell Boundaries” gives the most accurate plots, “Sample At Segment Centers” provides one sample per probed cell, and “Sample Uniformally” samples uniformally along the input line.

paraview.simple.PlotOverLinesFromCustomSource(*input, **params)

The Plot Over Lines From Custom Source filter samples the dataset attributes of the input data set at the points along multiple lines given by the source dataset. The values of the point-centered variables along these lines will be displayed in an XY Plot. This filter uses interpolation to determine the values at the selected point, whether or not it lies at an input point. This filter operates on any type of data and produces polygonal output (a polyline). One can use different sampling patterns with this filter. “Sample At Cell Boundaries” gives the most accurate plots, “Sample At Segment Centers” provides one sample per probed cells, and “Sample Uniformly” samples uniformly along the input line.

paraview.simple.PlotSelectionOverTime(*input, **params)

This filter extracts the selection over time, i.e. cell and/or point variables at a cells/point selected are extracted over time The output multiblock consists of 1D rectilinear grids where the x coordinate corresponds to time (the same array is also copied to a point array named Time or TimeData (if Time exists in the input)). If selection input is a Location based selection then the point values are interpolated from the nearby cells, ie those of the cell the location lies in.

paraview.simple.PointAndCellIds(*input, **params)

This filter generates scalars using cell and point ids. That is, the point attribute data scalars are generated from the point ids, and the cell attribute data scalars or field data are generated from the the cell ids. Note that in the case of an input HTG, only cell IDs generation is available.

paraview.simple.PointDatasetInterpolator(*input, **params)

This probes a point cloud PC on the Input with a set of points P (the filter Source), interpolating the data values from PC onto P. Note however that the descriptive phrase “point cloud” is a misnomer: PC can be represented by any dataset type, with the points of the dataset forming PC. Similarly, the output P can also be represented by any vtkDataSet type; and the topology/geometry structure of P is passed through to the output along with the newly interpolated arrays.

paraview.simple.PointDatatoCellData(*input, **params)

The Point

Data to Cell Data filter averages the values of the point attributes of the points of a cell to compute cell attributes. This filter operates on any type of dataset, and the output dataset is the same type as the input.

paraview.simple.PointInterpolator(*input, **params)

This probes a point cloud PC on the Input with a set of points P (the filter Source), interpolating the data values from PC onto P. Note however that the descriptive phrase “point cloud” is a misnomer: PC can be represented by any dataset type, with the points of the dataset forming PC. Similarly, the output P can also be represented by any vtkDataSet type; and the topology/geometry structure of P is passed through to the output along with the newly interpolated arrays.

paraview.simple.PointLineInterpolator(*input, **params)

This probes a point cloud PC on the Input with a set of points P (the filter Source), interpolating the data values from PC onto P. Note however that the descriptive phrase “point cloud” is a misnomer: PC can be represented by any dataset type, with the points of the dataset forming PC. Similarly, the output P can also be represented by any vtkDataSet type; and the topology/geometry structure of P is passed through to the output along with the newly interpolated arrays.

paraview.simple.PointPlaneInterpolator(*input, **params)

This probes a point cloud PC on the Input with a set of points P (the filter Source), interpolating the data values from PC onto P. Note however that the descriptive phrase “point cloud” is a misnomer: PC can be represented by any dataset type, with the points of the dataset forming PC. Similarly, the output P can also be represented by any vtkDataSet type; and the topology/geometry structure of P is passed through to the output along with the newly interpolated arrays.

paraview.simple.PointSetToOctreeImage(*input, **params)

PointSetToOctreeImage can be used to convert a point set to an image with a number of points per cell target and an unsigned char octree cell array. Each bit of the unsigned char indicates if the point-set had a point close to one of the 8 corners of the cell. It can optionally also output a cell array based on an input point array. This array will have 1 or many components that represent different functions i.e. last value, min, max, count, sum, mean.

paraview.simple.PointSource(*input, **params)

The point source creates

a specified number of points within a given radius about a specified center point.

paraview.simple.PointVolumeInterpolator(*input, **params)

This probes a point cloud PC on the Input with a set of points P (the filter Source), interpolating the data values from PC onto P. Note however that the descriptive phrase “point cloud” is a misnomer: PC can be represented by any dataset type, with the points of the dataset forming PC. Similarly, the output P can also be represented by any vtkDataSet type; and the topology/geometry structure of P is passed through to the output along with the newly interpolated arrays.

paraview.simple.PolyLineSource(*input, **params)

The Poly Line Source creates a poly line from an arbitrary number of specified points.

paraview.simple.PolyPointSource(*input, **params)

The Poly Point Source creates a poly data of points from an arbitrary number of specified points.

paraview.simple.PolylineLength(*input, **params)

vtkAppendArcLength is used for filter such as plot-over-line. In such cases, we need to add an attribute array that is the arc_length over the length of the probed line. That’s when vtkAppendArcLength can be used. It adds a new point-data array named “arc_length” with the computed arc length for each of the polylines in the input. For all other cell types, the arc length is set to 0.

paraview.simple.PrincipalComponentAnalysis(*input, **params)

This filter either computes a statistical model of a dataset or takes such a model as its second input. Then, the model (however it is obtained) may optionally be used to assess the input dataset. <p> This filter performs additional analysis above and beyond the multicorrelative filter. It computes the eigenvalues and eigenvectors of the covariance matrix from the multicorrelative filter. Data is then assessed by projecting the original tuples into a possibly lower-dimensional space. <p> Since the PCA filter uses the multicorrelative filter’s analysis, it shares the same raw covariance table specified in the multicorrelative documentation. The second table in the multiblock dataset comprising the model output is an expanded version of the multicorrelative version. <p> As with the multicorrelative filter, the second model table contains the mean values, the upper-triangular portion of the symmetric covariance matrix, and the non-zero lower-triangular portion of the Cholesky decomposition of the covariance matrix. Below these entries are the eigenvalues of the covariance matrix (in the column labeled “Mean”) and the eigenvectors (as row vectors) in an additional NxN matrix.

paraview.simple.ProbeLocation(*input, **params)

The Probe filter samples the data set attributes of the current data set at the points in a point cloud. The Probe filter uses interpolation to determine the values at the selected point, whether or not it lies at an input point. The Probe filter operates on any type of data and produces polygonal output (a point cloud).

paraview.simple.ProcessIdScalars(*input, **params)

ProcessIdScalars is a deprecated proxy. It will be automatically replaced by ProcessIds

paraview.simple.ProcessIds(*input, **params)

GenerateProcessIds is meant to fill in the ProcessIds attribute array, to know which processor owns which cells and points. It can generate it for both PointData and CellData. The ProcessIds array’s name will be “PointProcessIds” for PointData, and “CellProcessIds” for CellData. Note that if the input is an HyperTree Grid instance, only cell process IDs are available.

paraview.simple.ProgrammableAnnotation(*input, **params)

This filter will execute a python script to produce a text. The text should be contained in a vtkTable containing a single vtkStringArray, itself containing a single tuple. The filter keeps a copy of the python script in Script and creates a python Interpreter to run the script upon the first execution. To execute external python scripts on the ParaView server, use: execfile(‘full_path/script_name.py’). Documentation is found in the Programmable Filter and numpy integration section of the paraview documentation.

paraview.simple.ProgrammableFilter(*input, **params)

This filter will execute a python script to produce an output dataset. The filter keeps a copy of the python script in Script and creates a python Interpreter to run the script upon the first execution. To execute external python scripts on the ParaView server, use: execfile(‘full_path/script_name.py’). Documentation is found in the Programmable Filter and numpy integration section of the paraview documentation.

paraview.simple.ProgrammableSource(*input, **params)

This source will execute a python script to produce an output dataset. The source keeps a copy of the python script in Script and creates a python Interpreter to run the script upon the first execution. To execute external python scripts on the ParaView server, use: execfile(‘full_path/script_name.py’). Documentation is found in the Programmable Filter chapter of the ParaView Guide.

paraview.simple.Protractor(*input, **params)

The protractor can be used to

interactively (using a 3D widget) or manually (using the entries on the user interface) specify 3 points and then determine the angle between these three. To place points on the surface of any dataset, one can use the ‘p’ key shortcut.

paraview.simple.PythonAnimationCue(*input, **params)

Animation cue that can use python script for

animation.

paraview.simple.PythonAnnotation(*input, **params)

This filter uses Python to calculate an expression and display the result as an annotation in the render view. It depends heavily on the numpy and paraview.vtk modules. To use the parallel functions, mpi4py is also necessary. The expression is evaluated and the resulting scalar value or numpy array is added to the output as an array. See numpy integration, python annotation and python calculator documentation for the list of available functions. This filter tries to make it easy for the user to write expressions by defining certain variables. The filter tries to assign each array to a variable of the same name. If the name of the array is not a valid Python variable, it may be accessed through a variable with a sanitized version of that array name consisting of only ‘_’ and the alphanumeric characters in the name joined together with no spaces. Point coordinates from datasets that explicitly define them can be accessed using the variable named ‘points’.

paraview.simple.PythonCalculator(*input, **params)

This filter

uses Python to calculate an expression. It depends heavily on the numpy and paraview.vtk modules. To use the parallel functions, mpi4py is also necessary. The expression is evaluated and the resulting scalar value or numpy array is added to the output as an array. See numpy integration and python calculator documentation for the list of available functions. This filter tries to make it easy for the user to write expressions by defining certain variables. The filter tries to assign each array to a variable of the same name. If the name of the array is not a valid Python variable, it may be accessed through a variable with a sanitized version of that array name consisting of only ‘_’ and the alphanumeric characters in the name joined together with no spaces. Point coordinates from datasets that explicitly define them can be accessed using the variable named ‘points’.

paraview.simple.QuadricClustering(*input, **params)

The Quadric

Clustering filter produces a reduced-resolution polygonal approximation of the input polygonal dataset. This filter is the one used by ParaView for computing LODs. It uses spatial binning to reduce the number of points in the data set; points that lie within the same spatial bin are collapsed into one representative point.

paraview.simple.QuerySelect(QueryString='', FieldType='POINT', Source=None, InsideOut=False)

Selection by query expression.

Parameters

• QueryString (str) – string with NumPy-like boolean expression defining which attributes are selected

• FieldType (str) – attribute to select, e.g., ‘POINT’ or ‘CELL’

• Source (paraview.servermanager.source.Proxy) – if not set, then the selection will be on the active source

• InsideOut (bool) – Invert the selection so that attributes that do not satisfy the expression are selected instead of elements that do.

Returns

None

paraview.simple.RTXMLPolyDataReader(*input, **params)

paraview.simple.RampKeyFrame(*input, **params)

paraview.simple.RandomAttributes(*input, **params)

The Random Attributes filter creates random attributes including scalars and vectors. These attributes can be generated as point data or cell data. The generation of each component is normalized between a user-specified minimum and maximum value.

This filter provides that capability to specify the data type of the attributes and the range for each of the components.

Note that in the case of an input HTG, only cell random attribute generation is available.

paraview.simple.RandomVectors(*input, **params)

The Random

Vectors filter generates a point-centered array of random vectors. It uses a random number generator to determine the components of the vectors. This filter operates on any type of dataset, and the output dataset will be of the same type as the input.

paraview.simple.RectilinearDatatoPointSet(*input, **params)

The Rectilinear Grid to Point Set

filter takes a rectilinear grid object and produces an equivalent Structured Grid, which is a type of point set. This brings the data to a broader category of data storage but only adds a small amount of overhead. This filter can be helpful in applying filters that expect or manipulate point coordinates.

paraview.simple.RectilinearGridConnectivity(*input, **params)

Extracts material fragments from multiblock vtkRectilinearGrid datasets based on the selected volume fraction array(s) and a fraction isovalue and integrates the associated attributes.

paraview.simple.RectilinearGridGeometryFilter(*input, **params)

RectilinearGridGeometryFilter is a filter that extracts geometry from a rectilinear grid. By specifying appropriate i-j-k indices, it is possible to extract a point, a curve, a surface, or a “volume”. The volume is actually a (n x m x o) region of points. The extent specification is zero-offset. That is, the first k-plane in a 50x50x50 rectilinear grid is given by (0,49, 0,49, 0,0).

paraview.simple.RedistributeDataSet(*input, **params)

Redistribute data for load balancing. The filter either computes the bounding boxes, or uses a provided collection of bounding boxes, for distributing the data. Cells along partition boundaries can be uniquely assigned to a partition, duplicated among partitions, or split among the partitions. The output is an unstructured grid.

paraview.simple.ReductionFilter(*input, **params)

paraview.simple.Reflect(*input, **params)

Reflect is a deprecated proxy. It will be automatically replaced by AxisAlignedReflectionFilter

paraview.simple.ReloadFiles(proxy=None)

Forces a reader proxy to reload the data files.

Parameters

proxy (Reader proxy) – Reader proxy whose files should be reloaded. Optional, defaults to reloading files in the active source.

Returns

Returns True if files reloaded successfully, False otherwise

Return type

bool

paraview.simple.RemoteSourceProxy(*input, **params)

paraview.simple.RemoveCameraLink(linkName)

Remove a camera link with the given name.

Parameters

linkName (str) – Name of the link to remove.

paraview.simple.RemoveGhostInformation(*input, **params)

Removes ghost cells, point data and cell data ghost arrays. In the case of HyperTree Grid input, this filter removes the cell data ghost array and masks the ghost cells.

paraview.simple.RemoveLayout(proxy=None)

Remove the provided layout. If none is provided, remove the layout containing the active view. If it is the only layout it will create a new one with the same name as the removed one.

Parameters

proxy (Layout proxy or None.) – The layout proxy to remove. Optional, defaults to the layout containing the active view.

paraview.simple.RemoveLight(light)

Removes an existing light from its view.

Parameters

light (paraview.servermanager.Light) – The light to be removed.

paraview.simple.RemoveLink(linkName)

Remove a named link.

Parameters

linkName (str) – Name of the link to remove.

paraview.simple.RemoveSelectionLink(linkName)

Remove a selection link with the given name.

Parameters

linkName (str) – Name of the link to remove.

paraview.simple.RemoveViewsAndLayouts()

Removes all existing views and layouts.

paraview.simple.RenameArrays(*input, **params)

This forwards the data to the output and allow to modify array names in place.

paraview.simple.RenameLayout(newName, proxy=None)

Renames the given layout. If the given proxy is not registered in the ‘layouts’ group this method will have no effect.

Parameters

• newName (str) – The new name of the layout proxy

• layout – The layout proxy to rename. It must be a member of the ‘layouts’ groupd. Optional, defaults to renaming the active layout.

paraview.simple.RenameProxy(proxy, group, newName)

Renames the given proxy. This is the name used by FindSource() and is displayed in the Pipeline Browser.

Parameters

• proxy (Proxy object) – The proxy to be renamed

• group (str) – The group in which the proxy lives. Can be retrieved with proxy.GetXMLGroup()

• newName (str) – The new name of the proxy.

paraview.simple.RenameSource(newName, proxy=None)

Renames the given source proxy. If the given proxy is not registered in the ‘sources’ group this function will have no effect.

Parameters

• newName (str) – The new name of the source proxy

• proxy (Source proxy) – The source proxy to rename. It must be a member of the ‘sources’ group. Optional, defaults to renaming the active source.

paraview.simple.RenameView(newName, proxy=None)

Renames the given view. If the given proxy is not registered in the ‘views’ group this method will have no effect.

Parameters

• newName (str) – The new name of the view proxy

• proxy (View proxy) – The view proxy to rename. It must be a member of the ‘views’ group. Optional, defaults to renaming the active view.

paraview.simple.Render(view=None)

Renders the given view if given, otherwise renders the active view. If this is the first render and the view is a RenderView, the camera is reset.

Parameters

view (View proxy.) – The view to render. Optional, defaults to rendering the active view.

paraview.simple.RenderAllViews()

Renders all existing views.

paraview.simple.ReplaceReaderFileName(readerProxy, files, propName)

Replaces the readerProxy by a new one given a list of files.

Parameters

• readerProxy (Reader proxy.) – Reader proxy whose filename should be updated.

• files (list of str) – List of file names to be read by the reader.

• propName (str) – should be “FileNames” or “FileName” depending on the property name in the reader.

paraview.simple.ResampleAMR(*input, **params)

This

filter allows the user to specify a Region of Interest(ROI) within the AMR data-set and extract it as a uniform grid.

paraview.simple.ResampleToImage(*input, **params)

paraview.simple.ResampleToLine(*input, **params)

Resamples the input data set to a line.

paraview.simple.ResampleWithDataset(*input, **params)

This filter takes two inputs - Source Data Arrays, and samples the point and cell values of this input onto the point locations of the Destination Geometry input. The output has the same structure as the Destination Geometry input, but its point data has the resampled values from the Source Data Arrays.”

paraview.simple.ResetCamera(view=None)

Resets camera settings to make the whole scene visible while preserving orientation.

Parameters

view (View proxy.) – The camera for this view is reset. Optional, defaults to the active view.

paraview.simple.ResetCameraToDirection(position=None, direction=None, up=None, view=None, bounds=None, sphere_bounds=None)

Resets the settings of the camera to the given position and direction.

Parameters

• position (3-element tuple or list of floats.) – Position of the camera. (default: [0,0,0])

• direction (3-element tuple or list of floats.) – Direction of the camera. (default: [0, 0, -1])

• up (3-element tuple or list of floats.) – If provided, will be used as the camera’s up direction.

• view (View proxy.) – If provided, modifies the camera in this view.

• bounds (6-element tuple or list of floats.) – If provided, reset the camera using that bounds (min_x, max_x, min_y, max_y, min_z, max_z).

• sbounds (4-element tuple or list of floats.) – If provided, reset the camera using computed bounds from a sphere_bounds (center_x, center_y, center_z, radius).

>> ResetCameraToDirection( … direction=[-1, -1, -1], … sphere_bounds=(-5, -4, -3, 25), … )

>> ResetCameraToDirection( … direction=[-1, -1, -1], … bounds=( … -30, 20, … -29, 21, … -28, 22, … ), … )

paraview.simple.ResetProperty(propertyName, proxy=None, restoreFromSettings=True)

Resets a proxy property to its default value.

Parameters

• propertyName (str) – Name of the property to reset.

• proxy – The proxy whose property should be reset. Optional, defaults to the active source.

• restoreFromSettings (bool) – If True, the property will be reset to the default value stored in the settings if available, otherwise it will be reset to ParaView’s application default value. Optional, defaults to True.

paraview.simple.ResetSession()

Reset the session to its initial state. All pipeline readers, sources, filters extractors, and representations are removed.

paraview.simple.RestartedSimExodusReader(*input, **params)

When a simulation that outputs exodus files is restarted, typically you get a new set of output files. When you read them in your visualization, you often want to string these file sets together as if it was one continuous dump of files. This reader allows you to specify a metadata file that will implicitly string the files together. This is a distributed reader.

paraview.simple.RestartedSimSpyPlotReader(*input, **params)

When a CTH simulation is restarted, typically you get a new set of output files. When you read them in your visualization, you often want to string these file sets together as if it was one continuous dump of files. This reader allows you to specify a metadata file that will implicitly string the files together. This is a distributed reader.

paraview.simple.ReverseConnect(port=11111, ns=None)

Create a reverse connection to a server. First, disconnects from any servers, then listens on port and waits for an incoming connection from the server.

Parameters

port (int) – The port to listen on for incoming connections.

Returns

Connection object

Return type

paraview.simple.ReverseSense(*input, **params)

This filter reverses vertex ordering or normals for cells. In graphics 2d cells have a notion of front or back face. If you use the right hand rule and wind the vertices of a cell counter-clockwise (how your right fungers coil) then the front face is in the direction of your thumb (the normal aligns with your right thumb). If you need to reverse the normals, or change the winding order of a polydata this filter can be used.

paraview.simple.Ribbon(*input, **params)

The Ribbon

filter creates ribbons from the lines in the input data set. This filter is useful for visualizing streamlines. Both the input and output of this filter are polygonal data. The input data set must also have at least one point-centered vector array.

paraview.simple.RotationalExtrusion(*input, **params)

The Rotational Extrusion filter forms a surface by rotating the input about the Z axis. This filter is intended to operate on 2D polygonal data. It produces polygonal output.

paraview.simple.Ruler(*input, **params)

The ruler can be used to

interactively (using a 3D widget) or manually (using the entries on the user interface) specify two points and then determine the distance between the two points. To place points on the surface of any dataset, one can use the ‘p’ key shortcut.

paraview.simple.SAVGReader(*input, **params)

Reader for NIST SAVG files.

paraview.simple.SEPReader(*input, **params)

paraview.simple.SLACDataReader(*input, **params)

A reader for a data format

used by Omega3p, Tau3p, and several other tools used at the Standford Linear Accelerator Center (SLAC). The underlying format uses NetCDF to store arrays, but also imposes several conventions to form an unstructured grid of elements. This is a distributed reader.

paraview.simple.SLACParticleDataReader(*input, **params)

The SLAC Particle data reader.

paraview.simple.SPHDatasetInterpolator(*input, **params)

This filter uses SPH (smooth particle hydrodynamics) kernels to interpolate a data source onto an input structure. For example, while the data source is a set of particles, the data from these particles can be interpolated onto an input volume. Then the output (which consists of the input structure plus interpolated data) can then be visualized using classical visualization techniques such as isocontouring, slicing, heat maps and so on.

paraview.simple.SPHInterpolator(*input, **params)

This filter uses SPH (smooth particle hydrodynamics) kernels to interpolate a data source onto an input structure. For example, while the data source is a set of particles, the data from these particles can be interpolated onto an input object such as a line, plane or volume. Then the output (which consists of the input structure plus interpolated data) can then be visualized using classical visualization techniques such as isocontouring, slicing, heat maps and so on.

paraview.simple.SPHLineInterpolator(*input, **params)

This filter uses SPH (smooth particle hydrodynamics) kernels to interpolate a data source onto an input structure. For example, while the data source is a set of particles, the data from these particles can be interpolated onto an input line. Then the output (which consists of the input structure plus interpolated data) can then be visualized using classical visualization techniques such as isocontouring, slicing, heat maps and so on.

paraview.simple.SPHPlaneInterpolator(*input, **params)

This filter uses SPH (smooth particle hydrodynamics) kernels to interpolate a data source onto an input structure. For example, while the data source is a set of particles, the data from these particles can be interpolated onto an input plane. Then the output (which consists of the input structure plus interpolated data) can then be visualized using classical visualization techniques such as isocontouring, slicing, heat maps and so on.

paraview.simple.SPHVolumeInterpolator(*input, **params)

This filter uses SPH (smooth particle hydrodynamics) kernels to interpolate a data source onto an input structure. For example, while the data source is a set of particles, the data from these particles can be interpolated onto an input volume. Then the output (which consists of the input structure plus interpolated data) can then be visualized using classical visualization techniques such as isocontouring, slicing, heat maps and so on.

paraview.simple.STLReader(*input, **params)

The STL reader reads ASCII or

binary stereo lithography (STL) files. The expected file extension is .stl. The output of this reader is a polygonal dataset. This reader also supports file series.

paraview.simple.SaveAnimation(filename, viewOrLayout=None, scene=None, location=16, **params)

Save animation as a movie file or series of images.

SaveAnimation is used to save an animation as a movie file (avi, mp4, or ogv) or a series of images.

Parameters

• filename (str) – Name of the output file. The extension is used to determine the type of the output. Supported extensions are png, jpg, tif, bmp, and ppm. Based on platform (and build) configuration, avi, mp4, and ogv may be supported as well.

• viewOrLayout (View or layout proxy.) – The view or layout to save image from, defaults to None. If None, then the active view is used, if available. To save an image from a single view, this must be set to a view, to save an image from all views in a layout, pass the layout.

• scene (Animation scene proxy) – Animation scene to save. If not provided, then the active scene returned by GetAnimationScene is used.

• location (vtkPVSession.ServerFlags enum) – Location where the screenshot should be saved. This can be one of the following values: vtkPVSession.CLIENT, vtkPVSession.DATA_SERVER. The default is vtkPVSession.CLIENT.

Keyword Parameters (optional)

SaveAnimation supports all keyword parameters supported by SaveScreenshot. In addition, the following parameters are supported:

FrameRate (int):

Frame rate in frames per second for the output. This only affects the output when generated movies (avi or ogv), and not when saving the animation out as a series of images.

FrameWindow (tuple(int,int))

To save a part of the animation, provide the range in frames or timesteps index.

In addition, several format-specific keyword parameters can be specified. The format is chosen based on the file extension.

For Image-based file-formats that save series of images e.g. PNG, JPEG, following parameters are available.

SuffixFormat (string):

Format string used to convert the frame number to file name suffix.

FFMPEG avi file format supports following parameters.

Compression (int)

Set to 1 or True to enable compression.

Quality:

When compression is 1 (or True), this specifies the compression quality. 0 is worst quality (smallest file size) and 2 is best quality (largest file size).

VideoForWindows (VFW) avi file format supports following parameters.

Quality:

This specifies the compression quality. 0 is worst quality (smallest file size) and 2 is best quality (largest file size).

OGG/Theora file format supports following parameters.

Quality:

This specifies the compression quality. 0 is worst quality (smallest file size) and 2 is best quality (largest file size).

UseSubsampling:

When set to 1 (or True), the video will be encoded using 4:2:0 subsampling for the color channels.

paraview.simple.SaveData(filename, proxy=None, **extraArgs)

Save data produced by the proxy parameter into a file.

Properties to configure the writer can be passed in as keyword arguments. Example usage:

SaveData("sample.pvtp", source0)
SaveData("sample.csv", FieldAssociation="Points")

Parameters

• filenam – Path where output file should be saved.

• proxy (Source proxy.) – Proxy to save. Optional, defaults to saving the active source.

• extraArgs – A variadic list of key=value pairs giving values of specific named properties in the writer.

paraview.simple.SaveExtracts(**kwargs)

Generate extracts. Parameters are forwarded for ‘SaveAnimationExtracts’ Currently, supported keyword parameters are:

Parameters

• ExtractsOutputDirectory (str) – root directory for extracts. If the directory does not exist, it will be created.

• GenerateCinemaSpecification (bool) – If set to True, enables generation of a cinema specification.

• FrameRate (int) – The frame rate in frames-per-second if the extractor supports it.

• FrameStride (int) – The number of timesteps to skip after a timestep is saved.

• FrameWindow (2-element tuple or list of ints) – The range of timesteps to extract.

paraview.simple.SaveExtractsUsingCatalystOptions(options)

Generate extracts using a CatalystOptions object. This is intended for use when a Catalyst analysis script is being run in batch mode.

Parameters

options (CatalystOptions) – Catalyst options proxy

paraview.simple.SaveScreenshot(filename, viewOrLayout=None, saveInBackground=False, location=16, **params)

Save screenshot for a view or layout (collection of views) to an image.

SaveScreenshot is used to save the rendering results to an image.

Parameters

• filename (str) – Name of the image file to save to. The filename extension is used to determine the type of image file generated. Supported extensions are png, jpg, tif, bmp, and ppm.

• viewOrLayout (View or layout proxy. Optional.) – The view or layout to save image from, defaults to None. If None, then the active view is used, if available. To save image from a single view, this must be set to a view, to save an image from all views in a layout, pass the layout.

• saveInBackground (bool) – If set to True, the screenshot will be saved by a different thread and run in the background. In such circumstances, one can wait until the file is written by calling WaitForScreenshot(filename)().

• location (vtkPVSession.ServerFlags enum) – Location where the screenshot should be saved. This can be one of the following values: vtkPVSession.CLIENT, vtkPVSession.DATA_SERVER. Optional, defaults to vtkPVSession.CLIENT.

Keyword Parameters (optional)

ImageResolution (tuple(int, int))

A 2-tuple to specify the output image resolution in pixels as (width, height). If not specified, the view (or layout) size is used.

FontScaling (str)

Specify whether to scale fonts proportionally (“Scale fonts proportionally”) or not (“Do not scale fonts”). Defaults to “Scale fonts proportionally”.

SeparatorWidth (int)

When saving multiple views in a layout, specify the width (in approximate pixels) for a separator between views in the generated image.

SeparatorColor (tuple(float, float, float))

Specify the color for separator between views, if applicable.

OverrideColorPalette (:obj:str, optional)

Name of the color palette to use, if any. If none specified, current color palette remains unchanged.

StereoMode (str)

Stereo mode to use, if any. Available values are “No stereo”, “Red-Blue”, “Interlaced”, “Left Eye Only”, “Right Eye Only”, “Dresden”, “Anaglyph”, “Checkerboard”, “Side-by-Side Horizontal”, and the default “No change”.

TransparentBackground (int)

Set to 1 (or True) to save an image with background set to alpha=0, if supported by the output image format.

In addition, several format-specific keyword parameters can be specified. The format is chosen based on the file extension.

For JPEG (*.jpg), the following parameters are available (optional)

Quality (int) [0, 100]

Specify the JPEG compression quality. O is low quality (maximum compression) and 100 is high quality (least compression).

Progressive (int):

Set to 1 (or True) to save progressive JPEG.

For PNG (*.png), the following parameters are available (optional)

CompressionLevel (int) [0, 9]

Specify the zlib compression level. 0 is no compression, while 9 is maximum compression.

Legacy Parameters

Prior to ParaView version 5.4, the following parameters were available and are still supported. However, they cannot be used together with other keyword parameters documented earlier.

view (proxy)

Single view to save image from.

layout (proxy)

Layout to save image from.

magnification (int)

Magnification factor to use to save the output image. The current view (or layout) size is scaled by the magnification factor provided.

quality (int)

Output image quality, a number in the range [0, 100].

paraview.simple.SaveState(filename, location=16)

Save a ParaView statefile (.pvsm) to disk on a system provided by the location parameter.

Parameters

• filename (str) – Path where the state file should be saved.

• location (vtkPVServer.ServerFlags enum value) – Where the statefile should be save, e.g., pass vtkPVSession.CLIENT if the statefile is located on the client system (default value), pass in vtkPVSession.SERVERS if on the server.

paraview.simple.ScatterPlot(*input, **params)

This

filter creates a scatter plot from a dataset.

paraview.simple.SegYReader(*input, **params)

SEG-Y Reader reads SEG-Y data files. We create a Structured Grid for 2.5D SEG-Y and 3D data. If we set the StructuredGrid option to false we create a Image Data for 3D data. This saves memory and may speed-up certain algorithms, but the position and the shape of the data may not be correct. The axes for the data are: crossline, inline, depth.

paraview.simple.SelectCells(query=None, proxy=None)

Select cells satisfying the query.

Parameters

• query (str) – The selection query. If None, then all cells are selected.

• proxy (Source proxy) – The source proxy to select from. Optional, defaults to the active source.

Returns

Selection source

Return type

servermanager.sources.SelectionQuerySource

paraview.simple.SelectCellsThrough(Rectangle=[], View=None, Modifier=None)

Select all cells within a rectangular region regardless of their visibility.

• Rectangle - list containing bottom left (x1, y1) and top right (x2, y2) corner of a rectangle defining the selection region in the format [x1, y1, x2, y2]. Defined in pixels.

• View - the view in which to perform the selection. If None, uses the current active view.

paraview.simple.SelectCompositeDataIDs(IDs=[], FieldType='POINT', ContainingCells=False, Source=None, Modifier=None)

Select attributes by composite attribute IDs.

• IDs - list of IDs of attribute types to select. Defined as 3-tuples of (flat block index, process number, attribute ID) interleaved in a single list.

• FieldType - type of attribute to select, e.g., ‘POINT’, ‘CELL’

• ContainingCells - if True and FieldType is ‘POINT’, select the cells containing the

  points corresponding to the given IDs.

• Source - If not None, specifies the sources whose elements should be selected by ID.

• Modifier - ‘ADD’, ‘SUBTRACT’, ‘TOGGLE’, or None to define whether and how the selection

  should modify the existing selection.

paraview.simple.SelectGlobalIDs(IDs=[], FieldType='POINT', ContainingCells=False, Source=None, Modifier=None)

Select attributes by global IDs.

• IDs - list of IDs of attribute types to select. Defined as a list of global IDs.

• FieldType - type of attribute to select, e.g., ‘POINT’, ‘CELL’

• ContainingCells - if True and FieldType is ‘POINT’, select the cells containing the

  points corresponding to the given IDs.

• Source - If not None, specifies the sources whose elements should be selected by ID.

• Modifier - ‘ADD’, ‘SUBTRACT’, ‘TOGGLE’, or None to define whether and how the selection

  should modify the existing selection.

paraview.simple.SelectHierarchicalDataIDs(IDs=[], FieldType='POINT', ContainingCells=False, Source=None, Modifier=None)

Select attributes by hierarchical data IDs.

• IDs - list of IDs of attribute types to select. Defined as 3-tuples of (level, index, attribute ID) interleaved in a single list.

• FieldType - type of attribute to select, e.g., ‘POINT’, ‘CELL’

• ContainingCells - if True and FieldType is ‘POINT’, select the cells containing the

  points corresponding to the given IDs.

• Source - If not None, specifies the sources whose elements should be selected by ID.

• Modifier - ‘ADD’, ‘SUBTRACT’, ‘TOGGLE’, or None to define whether and how the selection

  should modify the existing selection.

paraview.simple.SelectIDs(IDs=[], FieldType='POINT', ContainingCells=False, Source=None, Modifier=None)

Select attributes by attribute IDs.

• IDs - list of IDs of attribute types to select. Defined as (process number, attribute ID) pairs interleaved in a single list. For multiblock datasets, this will select attributes on all blocks of the provided (processor number, attribute ID) pairs

• FieldType - type of attribute to select, e.g., ‘POINT’, ‘CELL’

• ContainingCells - if True and FieldType is ‘POINT’, select the cells containing the

  points corresponding to the given IDs.

• Source - If not None, specifies the sources whose elements should be selected by ID.

• Modifier - ‘ADD’, ‘SUBTRACT’, ‘TOGGLE’, or None to define whether and how the selection

  should modify the existing selection.

paraview.simple.SelectLocation(Locations=[], Source=None, Modifier=None)

Select points by location.

• Locations - list of x, y, z points to select.

• Source - if not set, then the selection will be on the active source

paraview.simple.SelectPedigreeIDs(IDs=[], FieldType='POINT', ContainingCells=False, Source=None, Modifier=None)

Select attributes by Pedigree IDs.

• IDs - list of IDs of attribute types to select. Defined as (domain, ID) pairs interleaved in a single list.

• FieldType - type of attribute to select, e.g., ‘POINT’, ‘CELL’

• ContainingCells - if True and FieldType is ‘POINT’, select the cells containing the

  points corresponding to the given IDs.

• Source - If not None, specifies the sources whose elements should be selected by ID.

• Modifier - ‘ADD’, ‘SUBTRACT’, ‘TOGGLE’, or None to define whether and how the selection

  should modify the existing selection.

paraview.simple.SelectPoints(query=None, proxy=None)

Select points satisfying the query.

Parameters

• query (str) – The selection query. If None, then all points are selected.

• proxy (Source proxy) – The source proxy to select from. Optional, defaults to the active source.

Returns

Selection source

Return type

servermanager.sources.SelectionQuerySource

paraview.simple.SelectPointsThrough(Rectangle=[], View=None, Modifier=None)

Select all points within a rectangular region regardless of their visibility.

• Rectangle - list containing bottom left (x1, y1) and top right (x2, y2) corner of a rectangle defining the selection region in the format [x1, y1, x2, y2]. Defined in pixels.

• View - the view in which to perform the selection. If None, uses the current active view.

paraview.simple.SelectSurfaceBlocks(Rectangle=[], View=None, Modifier=None)

Select visible blocks within a rectangular region.

• Rectangle - list containing bottom left (x1, y1) and top right (x2, y2) corner of a rectangle defining the selection region in the format [x1, y1, x2, y2]. Defined in pixels.

• View - the view in which to perform the selection. If None, uses the current active view.

• Modifier - ‘ADD’, ‘SUBTRACT’, ‘TOGGLE’, or None to define whether and how the selection should modify the existing selection.

paraview.simple.SelectSurfaceCells(Rectangle=[], Polygon=[], View=None, Modifier=None)

Select visible cells within a rectangular or polygon region.

• Rectangle - list containing bottom left (x1, y1) and top right (x2, y2) corner of a rectangle defining the selection region in the format [x1, y1, x2, y2]. Defined in pixels. If not empty, the Polygon parameter must be empty or None.

• Polygon - list of 2D points defining a polygon in which visible points should be selected,

  e.g., [x1, y1, x2, y2, …, xn, yn]. Defined in pixels. If not empty, the Rectangle parameter must be empty or None.

• View - the view in which to perform the selection. If None, uses the current active view.

• Modifier - ‘ADD’, ‘SUBTRACT’, ‘TOGGLE’, or None to define whether and how the selection should modify the existing selection.

paraview.simple.SelectSurfacePoints(Rectangle=[], Polygon=[], View=None, Modifier=None)

Select visible points within a rectangular or polygon region.

• Rectangle - list containing bottom left (x1, y1) and top right (x2, y2) corner of a rectangle defining the selection region in the format [x1, y1, x2, y2]. Defined in pixels. If not empty, the Polygon parameter must be empty or None.

• Polygon - list of 2D points defining a polygon in which visible points should be selected,

  e.g., [x1, y1, x2, y2, …, xn, yn]. Defined in pixels. If not empty, the Rectangle parameter must be empty or None.

• View - the view in which to perform the selection. If None, uses the current active view.

• Modifier - ‘ADD’, ‘SUBTRACT’, ‘TOGGLE’, or None to define whether and how the selection should modify the existing selection.

paraview.simple.SelectThresholds(Thresholds=[], ArrayName='', FieldType='POINT', Source=None, Modifier=None)

Select attributes in a source by thresholding on values in an associated array.

• Thresholds - list of lower and upper threshold bounds. Attributes with associated values in the selected array between any set of bounds will be selected.

• ArrayName - name of the array to threshold.

• FieldType - atttribute to select, e.g., ‘POINT’ or ‘CELL’

• Source - if not set, then the selection will be on the active source

class paraview.simple.SelectionProxy(**args)

Bases: paraview.servermanager.Proxy

Special proxy wrapper type for Selections.

paraview.simple.SelectionQuerySource(*input, **params)

paraview.simple.SelectionSourceBase(*input, **params)

Internal proxy used to define the common API for Selection Source proxies. Do not use.

paraview.simple.SerialHTGMultiBlock(*input, **params)

Writer to write a multiblock dataset in a xml-based vtk data file. Can be used for parallel writing as well as serial writing.

paraview.simple.SetActiveConnection(connection=None, ns=None)

Set the active connection. If the process was run without multi-server enabled and this method is called with a non-None argument while an ActiveConnection is present, it will raise a RuntimeError.

Parameters

• connection (Connection object.) – If provided, changes the current connection.

• ns – Namespace in which functions from the old Connection are removed and functions in the new Connection are added.

Raises

RuntimeError – If called when ParaView is not running in multi-server mode, a RuntimeError will be raised.

paraview.simple.SetActiveSource(source)

Sets the active source.

Parameters

source (Source proxy) – The source

paraview.simple.SetActiveView(view)

Sets the active view.

Parameters

view (View proxy.) – The view to make active.

paraview.simple.SetDisplayProperties(proxy=None, view=None, **params)

DEPRECATED: Should use SetRepresentationProperties() instead

paraview.simple.SetNumberOfCallbackThreads(n)

Sets the number of threads used by the threaded callback queue that can be used for saving screenshots.

Parameters

n (int) – Number of callback threads.

paraview.simple.SetNumberOfSMPThreads(n)

Sets the number of threads used by vtkSMPTools. It is used in various filters.

paraview.simple.SetProperties(proxy=None, **params)

Sets one or more properties of the given pipeline source. If an argument is not provided, the active source is used. Pass in arguments of the form property_name=value to this function to set property values. For example:

SetProperties(Center=[1, 2, 3], Radius=3.5)

Parameters

• proxy (Source proxy) – The pipeline source whose properties should be set. Optional, defaultst to the active source.

• params – A variadic list of key=value pairs giving values of specific named properties in the pipeline source. For a list of available properties, call help(proxy).

paraview.simple.SetRepresentationProperties(proxy=None, view=None, **params)

Sets one or more representation properties of the given pipeline source.

Pass a list of property_name=value pairs to this function to set property values. For example:

SetProperties(Color=[1, 0, 0], LineWidth=2)

Parameters

• proxy (Source proxy) – Pipeline source whose representation properties should be set. Optional, defaults to the active source.

• view (View proxy) – The view in which to make the representation property changes. Optional, defaults to the active view.

paraview.simple.SetViewProperties(view=None, **params)

Sets one or more properties of the given view. If an argument is not provided, the active view is used. Pass in arguments of the form property_name=value to this function to set property values. For example:

SetProperties(Background=[1, 0, 0], UseImmediateMode=0)

Parameters

• view (View proxy.) – The view whose properties are to be set. If not provided, the active view is used.

• params – A variadic list of key=value pairs giving values of specific named properties in the view. For a list of available properties, call help(view).

paraview.simple.Show(proxy=None, view=None, representationType=None, **params)

Turns on the visibility of a given pipeline proxy in the given view. If pipeline proxy and/or view are not specified, active objects are used.

Parameters

• proxy (Source proxy.) – The pipeline proxy to show. If not provided, uses the active source.

• view (View proxy.) – The view proxy to show the source proxy in. Optional, defaults to the active view.

• representationType (str) – Name of the representation type to use. Optional, defaults to a suitable representation for the source proxy and view.

Returns

The representation proxy for the source proxy in the view.

Return type

Representation proxy.:

paraview.simple.ShowAll(view=None)

Show all pipeline sources in the given view.

Parameters

view (View proxy. Optional, defaults to the active view.) – The view in which to show all pipeline sources.

paraview.simple.ShowInteractiveWidgets(proxy=None)

If possible in the current environment, this function will request the application to show the interactive widget(s) for the given proxy.

Parameters

proxy (Source proxy.) – The proxy whose associated interactive widgets should be shown. Optional, if not provided the active source’s widgets are shown.

paraview.simple.Shrink(*input, **params)

The Shrink filter

causes the individual cells of a dataset to break apart from each other by moving each cell’s points toward the centroid of the cell. The centroid of a cell is the average position of its points. This filter operates on any type of dataset and produces unstructured grid output.

paraview.simple.SinusoidKeyFrame(*input, **params)

paraview.simple.Slice(*input, **params)

This filter

extracts the portion of the input dataset that lies along the specified plane. The Slice filter takes any type of dataset or hyper tree grid as input. The output of this filter is polygonal data.

paraview.simple.SliceAlongPolyLine(*input, **params)

The Slice Along PolyLine filter is similar to the Slice Filter except that it slices along a surface that is defined by sweeping the input polyline parallel to the z-axis. Explained another way: take a laser cutter and move it so that it hits every point on the input polyline while keeping it parallel to the z-axis. The surface cut from the input dataset is the result.

paraview.simple.SliceGenericDataset(*input, **params)

The

Generic Cut filter extracts the portion of the input data set that lies along the specified plane or sphere. From the Cut Function menu, you can select whether cutting will be performed with a plane or a sphere. The appropriate 3D widget (plane widget or sphere widget) will be displayed. The parameters of the cut function can be specified interactively using the 3D widget or manually using the traditional user interface controls. Instructions for using these 3D widgets and their corresponding user interfaces are found in section 7.4. By default, the cut lies on the specified plane or sphere. Using the Cut Offset Values portion of the interface, it is also possible to cut the data set at some offset from the original cut function. The Cut Offset Values are in the spatial units of the data set. To add a single offset, select the value from the New Value slider in the Add value portion of the interface and click the Add button, or press Enter. To instead add several evenly spaced offsets, use the controls in the Generate range of values section. Select the number of offsets to generate using the Number of Values slider. The Range slider controls the interval in which to generate the offsets. Once the number of values and range have been selected, click the Generate button. The new offsets will be added to the Offset Values list. To delete a value from the Cut Offset Values list, select the value and click the Delete button. (If no value is selected, the last value in the list will be removed.) Clicking the Delete All button removes all the values in the list. The Generic Cut filter takes a generic dataset as input. Use the Input menu to choose a data set to cut. The output of this filter is polygonal data.

paraview.simple.SliceWithPlane(*input, **params)

This filter extracts the portion of the input dataset that lies along the specified plane. The Slice filter takes any type of dataset as input. This is a multithreaded implementation.

paraview.simple.Smooth(*input, **params)

The Smooth filter operates on a polygonal data set by iteratively adjusting the position of the points using Laplacian smoothing. (Because this filter only adjusts point positions, the output data set is also polygonal.) This results in better-shaped cells and more evenly distributed points. The Convergence slider limits the maximum motion of any point. It is expressed as a fraction of the length of the diagonal of the bounding box of the data set. If the maximum point motion during a smoothing iteration is less than the Convergence value, the smoothing operation terminates.

paraview.simple.SpatioTemporalHarmonics(*input, **params)

The Spatio Temporal Harmonics Attribute filter adds an array for point data. The values are computed for each point with the harmonics defined in the filter. Harmonics are defined by their amplitude, temporal frequency, wave vector, and phase.

paraview.simple.SpatioTemporalHarmonicsUniformGrid(*input, **params)

Creates a 3D uniform grid with point data. The values are computed for each point with the harmonics defined in the source. Harmonics are defined by their amplitude, temporal frequency, wave vector, and phase. The grid is defined by its extent.

paraview.simple.Sphere(*input, **params)

The Sphere source can be

used to add a polygonal sphere to the 3D scene. The output of the Sphere source is polygonal data with point normals defined.

paraview.simple.SplineSource(*input, **params)

This class

tessellates parametric functions. The user must specify how many points in the parametric coordinate directions are required (i.e., the resolution), and the mode to use to generate scalars.

paraview.simple.SpyPlotReader(*input, **params)

The Spy

Plot reader loads an ASCII meta-file called the “case” file (extension .spcth). The case file lists all the binary files containing the dataset. This reader produces hierarchical datasets. This is a distributed reader.

paraview.simple.StitchImageDataWithGhosts(*input, **params)

Stitches images that are separated by one voxel, effectively generating ghost points at the new interfaces between the input images. Setting NumberOfGhosts to n stitches the images and generates n-1 layers of ghost cells. The inputs CANNOT have any cell data, or the filter will not run.

paraview.simple.StreakLine(*input, **params)

The Particle Trace filter generates pathlines in a vector field from a collection of seed points. The vector field used is selected from the Vectors menu, so the input data set is required to have point-centered vectors. The Seed portion of the interface allows you to select whether the seed points for this integration lie in a point cloud or along a line. Depending on which is selected, the appropriate 3D widget (point or line widget) is displayed along with traditional user interface controls for positioning the point cloud or line within the data set. Instructions for using the 3D widgets and the corresponding manual controls can be found in section 7.4. This filter operates on any type of data set, provided it has point-centered vectors. The output is polygonal data containing polylines. This filter is available on the Toolbar.

paraview.simple.StreamTracer(*input, **params)

The

Stream Tracer filter generates streamlines in a vector field from a collection of seed points. Production of streamlines terminates if a streamline crosses the exterior boundary of the input dataset (ReasonForTermination=1). Other reasons for termination include an initialization issue (ReasonForTermination=2), computing an unexpected value (ReasonForTermination=3), reached the Maximum Streamline Length input value (ReasonForTermination=4), reached the Maximum Steps input value (ReasonForTermination=5), and velocity was lower than the Terminal Speed input value (ReasonForTermination=6). This filter operates on any type of dataset, provided it has point-centered vectors. The output is polygonal data containing polylines.

paraview.simple.StreamTracerForGenericDatasets(*input, **params)

The

Generic Stream Tracer filter generates streamlines in a vector field from a collection of seed points. The vector field used is selected from the Vectors menu, so the input data set is required to have point-centered vectors. The Seed portion of the interface allows you to select whether the seed points for this integration lie in a point cloud or along a line. Depending on which is selected, the appropriate 3D widget (point or line widget) is displayed along with traditional user interface controls for positioning the point cloud or line within the data set. Instructions for using the 3D widgets and the corresponding manual controls can be found in section 7.4. The Max. Propagation entry box allows you to specify the maximum length of the streamlines. From the Max. Propagation menu, you can select the units to be either Time (the time a particle would travel with steady flow) or Length (in the data set’s spatial coordinates). The Init. Step Len. menu and entry specify the initial step size for integration. (For non-adaptive integrators, Runge-Kutta 2 and 4, the initial step size is used throughout the integration.) The menu allows you to specify the units. Time and Length have the same meaning as for Max. Propagation. Cell Length specifies the step length as a number of cells. The Integration Direction menu determines in which direction(s) the stream trace will be generated: FORWARD, BACKWARD, or BOTH. The Integrator Type section of the interface determines which calculation to use for integration: Runge-Kutta 2, Runge-Kutta 4, or Runge-Kutta 4-5. If Runge-Kutta 4-5 is selected, controls are displayed for specifying the minimum and maximum step length and the maximum error. The controls for specifying Min. Step Len. and Max. Step Len. are the same as those for Init. Step Len. The Runge-Kutta 4-5 integrator tries to choose the step size so that the estimated error is less than the value of the Maximum Error entry. If the integration takes more than Max. Steps to complete, if the speed goes below Term. Speed, if Max. Propagation is reached, or if a boundary of the input data set is crossed, integration terminates. This filter operates on any type of data set, provided it has point-centered vectors. The output is polygonal data containing polylines.

paraview.simple.StreamTracerWithCustomSource(*input, **params)

The

Stream Tracer With Custom Source filter generates streamlines in a vector field from a collection of seed points. Production of streamlines terminates if a streamline crosses the exterior boundary of the input dataset (ReasonForTermination=1). Other reasons for termination include an initialization issue (ReasonForTermination=2), computing an unexpected value (ReasonForTermination=3), reached the Maximum Streamline Length input value (ReasonForTermination=4), reached the Maximum Steps input value (ReasonForTermination=5), and velocity was lower than the Terminal Speed input value (ReasonForTermination=6). This filter operates on any type of dataset, provided it has point-centered vectors. The output is polygonal data containing polylines. This filter takes a Source input that provides the seed points.

paraview.simple.Subdivide(*input, **params)

The Subdivide filter iteratively divides each triangle in the input dataset into 4 new triangles. Three new points are added per triangle – one at the midpoint of each edge. This filter operates only on polygonal data containing triangles, so run your polygonal data through the Triangulate filter first if it is not composed of triangles. The output of this filter is also polygonal.

paraview.simple.Superquadric(*input, **params)

The Superquadric source can be used to add a polygonal superquadric to the 3D scene. This source can be used to create a wide variety of shapes (e.g., a sphere, a box, or a torus) by adjusting the roundness parameters. The output of the Superquadric source is polygonal data with point normals and texture coordinates defined.

paraview.simple.SurfaceFlow(*input, **params)

The flow integration filter integrates the dot product of a point flow vector field and surface normal. It computes the net flow across the 2D surface. It operates on any type of dataset and produces an unstructured grid output.

paraview.simple.SurfaceNormals(*input, **params)

This filter generates surface normals at the points of the input polygonal dataset to provide smooth shading of the dataset. The resulting dataset is also polygonal. The filter works by calculating a normal vector for each polygon in the dataset and then averaging the normals at the shared points.

paraview.simple.SurfaceTangents(*input, **params)

This filter

generates surface tangents at the points of the input polygonal dataset based on the normals and the texture coordinates. The resulting dataset is also polygonal. The tangents are required when using a normal texture.

paraview.simple.SurfaceVectors(*input, **params)

The Surface Vectors filter is used for 2D data sets. It constrains vectors to lie in a surface by removing components of the vectors normal to the local surface.

paraview.simple.SynchronizeTime(*input, **params)

Synchronize time step values in the first input (Input) to time step values in the second input (Source) that are considered close enough. The outputted dataset is from the first input and the number of output time steps is also equal to the number of time steps in the first input. Time step values in the first input that are “close” to time step values in the second input are replaced with the value from the second input. Close is determined to be if the difference is less than RelativeTolerance multiplied by the time range of the first input.

paraview.simple.TIFFReader(*input, **params)

The TIFF reader reads TIFF

(Tagged Image File Format) files, and the output is a uniform rectilinear (image/volume) dataset. The default file extension is .tiff.

paraview.simple.TIFFSeriesReader(*input, **params)

The TIFF series

reader reads TIFF files. The output is a time sequence of uniform rectilinear (image/volume) dataset. The default file extension is .tif or .tiff.

paraview.simple.TIFFWriter(*input, **params)

Writer to

write image data as a TIFF file.

paraview.simple.TRUCHASReader(*input, **params)

Reads TRUCHAS simulation output stored in HDF5.

paraview.simple.TableFFT(*input, **params)

Performs the Fast Fourier Transform on the columns of a table.

paraview.simple.TableToPoints(*input, **params)

The

TableToPolyData filter converts a vtkTable to a set of points in a vtkPolyData. One must specifies the columns in the input table to use as the X, Y and Z coordinates for the points in the output.

paraview.simple.TableToStructuredGrid(*input, **params)

The

TableToStructuredGrid filter converts a vtkTable to a vtkStructuredGrid. One must specifies the columns in the input table to use as the X, Y and Z coordinates for the points in the output, and the whole extent.

paraview.simple.TecplotReader(*input, **params)

The Tecplot reader extracts multiple zones (blocks) of data from a Tecplot ASCII file, in which a zone is stored in either point packing mode (i.e., tuple-based, with only point data supported) or block packing mode (i.e., component-based, with point data and cell data supported). The output of the reader is a vtkMultiBlockDataset, of which each block is either a vtkStructuredGrid or a vtkUnstructuredGrid. This supports reading a file series.

paraview.simple.TecplotTableReader(*input, **params)

The Tecplot

table reader reads a .DAT file containing tabular data into a spreadsheet view.

paraview.simple.TemporalArrayOperator(*input, **params)

Filter used to perform an operation on a data array at 2 different timesteps.

paraview.simple.TemporalCache(*input, **params)

The Temporal Cache

can be used to save multiple copies of a data set at different time steps to prevent thrashing in the pipeline caused by downstream filters that adjust the requested time step. For example, assume that there is a downstream Temporal Interpolator filter. This filter will (usually) request two time steps from the upstream filters, which in turn (usually) causes the upstream filters to run twice, once for each time step. The next time the interpolator requests the same two time steps, they might force the upstream filters to re-evaluate the same two time steps. The Temporal Cache can keep copies of both of these time steps and provide the requested data without having to run upstream filters.

paraview.simple.TemporalCacheSource(*input, **params)

The Temporal Cache

can be used to save multiple copies of a data set at different time steps to prevent thrashing in the pipeline caused by downstream filters that adjust the requested time step. For example, assume that there is a downstream Temporal Interpolator filter. This filter will (usually) request two time steps from the upstream filters, which in turn (usually) causes the upstream filters to run twice, once for each time step. The next time the interpolator requests the same two time steps, they might force the upstream filters to re-evaluate the same two time steps. The Temporal Cache can keep copies of both of these time steps and provide the requested data without having to run upstream filters.

paraview.simple.TemporalInterpolator(*input, **params)

The Temporal Interpolator converts data that is defined at discrete time steps to one that is defined over a continuum of time by linearly interpolating the data’s field data between two adjacent time steps. The interpolated values are a simple approximation and should not be interpreted as anything more. The Temporal Interpolator assumes that the topology between adjacent time steps does not change.

paraview.simple.TemporalParticlesToPathlines(*input, **params)

Particle Pathlines takes any dataset as input, it extracts the point locations of all cells over time to build up a polyline trail. The point number (index) is used as the ‘key’ if the points are randomly changing their respective order in the points list, then you should specify a scalar that represents the unique ID. This is intended to handle the output of a filter such as the TemporalStreamTracer.

paraview.simple.TemporalShiftScale(*input, **params)

The Temporal

Shift Scale filter linearly transforms the time values of a pipeline object by applying a shift and then scale. Given a data at time t on the input, it will be transformed to time t*Shift + Scale on the output. Inversely, if this filter has a request for time t, it will request time (t-Shift)/Scale on its input.

paraview.simple.TemporalSmoothing(*input, **params)

Given an input that changes over time, Temporal Smoothing will provide an average of each point and cell data values over a temporal window centered on a requested time step. Because of this, the input’s topology is assumed to not change over time, and so the number and order of its points and cells should stay the same. In order to provide comparable results for different time steps, the temporal window must be the same size. To enforce this the filter clips its input available time steps to allow the full window size to fit. If an out-of-bound time step is requested, the filter will use the closest available time step. Note that updating this filter will trigger upstream updates for each time steps of the window, which could be expensive.

paraview.simple.TemporalSnaptoTimeStep(*input, **params)

This file modifies the time range or time steps of the data without changing the data itself. The data is not resampled by this filter, only the information accompanying the data is modified.

paraview.simple.TemporalStatistics(*input, **params)

Given an input

that changes over time, Temporal Statistics looks at the data for each time step and computes some statistical information of how a point or cell variable changes over time. For example, Temporal Statistics can compute the average value of “pressure” over time of each point. Note that this filter will require the upstream filter to be run on every time step that it reports that it can compute. This may be a time consuming operation. Temporal Statistics ignores the temporal spacing. Each timestep will be weighted the same regardless of how long of an interval it is to the next timestep. Thus, the average statistic may be quite different from an integration of the variable if the time spacing varies.

paraview.simple.TensorGlyph(*input, **params)

The Tensor Glyph filter generates an ellipsoid, cuboid, cylinder or superquadric glyph at every point in the input data set. The glyphs are oriented and scaled according to eigenvalues and eigenvectors of tensor point data of the input data set. The Tensor Glyph filter operates on any type of data set. Its output is polygonal. This filter supports symmetric tensors. Symmetric tensor components are expected to have the following order: XX, YY, ZZ, XY, YZ, XZ”

paraview.simple.TensorPrincipalInvariants(*input, **params)

This filter computes principal values and directions for 2D and 3D tensors. The principal vectors can be scaled by their corresponding principal values.

paraview.simple.Tessellate(*input, **params)

The Tessellate filter

tessellates cells with nonlinear geometry and/or scalar fields into a simplicial complex with linearly interpolated field values that more closely approximate the original field. This is useful for datasets containing quadratic cells.

paraview.simple.TessellateGenericDataset(*input, **params)

Tessellate

a higher-order dataset.

paraview.simple.Test3DWidget(*input, **params)

paraview.simple.Tetrahedralize(*input, **params)

The

Tetrahedralize filter converts the 3D cells of any type of dataset to tetrahedrons and the 2D ones to triangles. This filter always produces unstructured grid output.

paraview.simple.Text(*input, **params)

The Text source is used to generate a vtkTable with a single text string. To create a table with several columns, use the ‘|’ (pipe) character. To create several rows, simply add newlines.

paraview.simple.TextureMaptoCylinder(*input, **params)

This is a filter that generates 2D texture coordinates by mapping input dataset points onto a cylinder. The cylinder is generated automatically. The cylinder is generated automatically by computing the axis of the cylinder. Note that the generated texture coordinates for the s-coordinate ranges from (0-1) (corresponding to angle of 0->360 around axis), while the mapping of the t-coordinate is controlled by the projection of points along the axis.

paraview.simple.TextureMaptoPlane(*input, **params)

TextureMapToPlane is a filter that generates 2D texture coordinates by mapping input dataset points onto a plane. The plane is generated automatically. A least squares method is used to generate the plane automatically.

paraview.simple.TextureMaptoSphere(*input, **params)

This is a filter that generates 2D texture coordinates by mapping input dataset points onto a sphere. The sphere is generated automatically. The sphere is generated automatically by computing the center i.e. averaged coordinates, of the sphere. Note that the generated texture coordinates range between (0,1). The s-coordinate lies in the angular direction around the z-axis, measured counter-clockwise from the x-axis. The t-coordinate lies in the angular direction measured down from the north pole towards the south pole.

paraview.simple.Threshold(*input, **params)

The Threshold filter extracts the portions of the input dataset whose scalars lie within the specified range. This filter operates on either point-centered or cell-centered data. It operates on any type of dataset and produces unstructured grid output. The scalar array from which to threshold the data can be selected in the ‘Scalars’ menu. For a multi-components array, ‘Selected Component’ menu allows you to select a specific component or magnitude if using the ‘Selected’ component mode. You can also choose ‘All’ or ‘Any’ that will keep data if either all components or at least one satisfies the threshold. Note that multi-components arrays are not available with Hyper Tree Grid inputs. The ‘Lower Threshold’ and ‘Upper Threshold’ sliders determine the range of the scalars to retain in the output. The threshold method can be selected from the ‘Threshold Method’ menu. The ‘All Scalars’ option only applies to Point Data. When this option is on, a cell will only be passed to the output if the scalar values of all of its points lie within the chosen range. When off, a cell will be added to the output if the specified scalar value for any of its points is within the chosen range.

paraview.simple.ThresholdSelectionSource(*input, **params)

ThresholdSelectionSource is used to create a threshold based selection.

paraview.simple.ThresholdTable(*input, **params)

The Threshold Table Filter uses minimum and/or maximum values to threshold table rows based on the values in a particular column of a vtkTable object. It operates on scalar fields, and accepts two thresholding parameters: MinValue and MaxValue. This filter offers four different thresholding methods : “Below Max Threshold”, “Above Min Threshold”, “Between”, and “Outside”. The output of this filter is a vtkTable object with less or as many rows as the input vtkTable.

paraview.simple.TimeAnimationCue(*input, **params)

This is same as KeyFrameAnimationCue except that it has a

new property “UseAnimationTime” which when set overrides the keyframes all together and directly uses the animation clock time to update the animated property.

paraview.simple.TimeSource(*input, **params)

Produces a

single cell uniform grid with data values that vary over a sin(t) wave from t=0 to t=1 (radian).

paraview.simple.TimeStepProgressBar(*input, **params)

The Time Step Progress Bar

filter can be used to show the relative position of the actual time step/value relatively to the number of timesteps/data time range in a progress bar.

paraview.simple.Transform(*input, **params)

The Transform

filter allows you to specify the position, size, and orientation of polygonal, unstructured grid, and curvilinear datasets.

paraview.simple.TransposeTable(*input, **params)

paraview.simple.TriangleStrips(*input, **params)

The

Triangle Strips filter converts triangles into triangle strips and lines into polylines. This filter operates on polygonal data sets and produces polygonal output.

paraview.simple.Triangulate(*input, **params)

The

Triangulate filter decomposes polygonal data into only triangles, points, and lines. It separates triangle strips and polylines into individual triangles and lines, respectively. The output is polygonal data. Some filters that take polygonal data as input require that the data be composed of triangles rather than other polygons, so passing your data through this filter first is useful in such situations. You should use this filter in these cases rather than the Tetrahedralize filter because they produce different output dataset types. The filters referenced require polygonal input, and the Tetrahedralize filter produces unstructured grid output.

paraview.simple.TrivialProducer(*input, **params)

paraview.simple.Tube(*input, **params)

The Tube filter

creates tubes around the lines in the input polygonal dataset. The output is also polygonal.

paraview.simple.UnstructuredCellTypes(*input, **params)

Generate cells of the specified type. If a 1D cell type is chosen then only the first value of BlocksDimension is used. If a 2D cell type is chosen then only the first and second value of BlocksDimension is used. A cell block may be divided into multiple cells (e.g. 6 pyramids will be in a cell block).

Note that not all meshes generated for Lagrange cells (particularly tetrahedra) will be conformal; their boundaries will not meet exactly at block boundaries.

paraview.simple.UnstructuredNetCDFPOPreader(*input, **params)

The reader reads regular rectilinear grid (image/volume) data from a NetCDF file and turns it into an unstructured spherical grid. This is a distributed reader.

paraview.simple.UpdatePipeline(time=None, proxy=None)

Updates (executes) the given pipeline object for the given time as necessary (i.e., if it did not already execute).

Parameters

• time (float) – The time at which to update the pipeline. Optional, defaults to updating the currently loaded timestep.

• proxy (Source proxy.) – Source proxy to update. Optional, defaults to updating the active source.

paraview.simple.UpdateScalarBars(view=None)

Hides all unused scalar bars and shows used scalar bars. A scalar bar is used if some data is shown in that view that is coloring using the transfer function shown by the scalar bar.

Parameters

view (View proxy) – The view in which scalar bar visibility should be changed. Optional, defaults to using the active view.

paraview.simple.UpdateScalarBarsComponentTitle(ctf, representation=None)

Update the component portion of the title in all scalar bars using the provided lookup table. The representation is used to recover the array from which the component title was obtained.

Parameters

• ctf (Transfer function proxy.) – The lookup table that the scalar bar represents. Optional, defaults to the representation of the active source in the active view.

• representation (Representation proxy) – If provided, it is the representation to use to recover the array that provides the component title portion. Optional, defaults to the active representation.

Returns

True if operation succeeded, False otherwise.

Return type

bool

paraview.simple.UpdateSteerableParameters(steerable_proxy, steerable_source_name)

Updates a steerable proxy of a provided source name.

Parameters

• steerable_proxy (Source proxy.) – The steerable proxy to update.

• steerable_source_name (str) – The name of the steerable source proxy.

paraview.simple.VASPAnimationReader(*input, **params)

paraview.simple.VASPTessellationReader(*input, **params)

paraview.simple.VPICReader(*input, **params)

VPIC is a 3D

kinetic plasma particle-in-cell simulation. The input file (.vpc) opened by the VPIC reader is an ASCII description of the data files which are written one file per processor, per category and per time step. These are arranged in subdirectories per category (field data and hydrology data) and then in time step subdirectories. This is a distributed reader.

paraview.simple.VRMLReader(*input, **params)

The VRML reader loads

only the geometry from a VRML (Virtual Reality Modeling Language) 2.0 file. The expected file extension is .wrl. The output of this reader is a polygonal dataset.

paraview.simple.VTKHDFReader(*input, **params)

Reads VTKHDF serial or parallel data files. All data types are read from the same reader. This reader also supports file series.

paraview.simple.VTKHDFWriter(*input, **params)

The VTKHDF Writer writes files in VTKHDF format, using extension .vtkhdf, a format derived from HDF5. Currently, it supports writing Unstructured Grid and PolyData datasets, possibly transient, as well as composite types Partitioned Dataset Collection and Multiblock Dataset, without transient support.

paraview.simple.ValidateCells(*input, **params)

paraview.simple.ValueSelectionSource(*input, **params)

ValueSelectionSource is a source producing a value based selection. This cannot be used for selecting composite datasets.

paraview.simple.VelodyneAMRReader(*input, **params)

This Velodyne AMR reader loads data stored in XAMR format. The output of this reader is a vtkOverlappingAMR dataset.

paraview.simple.VolumeOfRevolution(*input, **params)

paraview.simple.VortexCores(*input, **params)

Compute vortex core lines using the parallel vectors method. By default, the “Higher-Order” approach of computing the parallel vector lines between the flow field’s velocity and jerk is disabled in favor of computing the parallel vector lines between the velocity and acceleration. To further discriminate against spurious vortex cores, at each potential point value the Q-criterion, delta-criterion, lambda_ci, and lambda_2-criterion are checked. The Q-criterion and delta-criterion are used to prefilter cells prior to the execution of the parallel lines algorithm, and all criteria values are stored as point values on the output polylines.

paraview.simple.WaitForScreenshot(filename=None)

Pause this thread until saving a screenshot has terminated.

Parameters

filename (str) – Path where screenshot should be saved. If no filename is provided, then this thread pauses until all screenshots have been saved.

paraview.simple.WarpByScalar(*input, **params)

The Warp By Scalar filter translates the points of the input dataset along a vector by a distance determined by the specified scalars. This filter operates on polygonal, curvilinear, and unstructured grid datasets containing single-component scalar arrays. Because it only changes the positions of the points, the output dataset type is the same as that of the input. Any scalars in the input dataset are copied to the output, so the data can be colored by them.

paraview.simple.WarpByVector(*input, **params)

The Warp By Vector filter translates the points of the input dataset using a specified vector array. The vector array chosen specifies a vector per point in the input. Each point is translated along its vector by a given scale factor. This filter operates on polygonal, curvilinear, and unstructured grid datasets. Because this filter only changes the positions of the points, the output dataset type is the same as that of the input.

paraview.simple.WavefrontOBJReader(*input, **params)

The OBJ reader

reads data stored in Wavefront .OBJ format. The expected file extension is .obj, the datasets resulting from reading these files are polygons and lines.

paraview.simple.Wavelet(*input, **params)

The Wavelet source can be used to create a uniform rectilinear grid in up to three dimensions with values varying according to the following periodic function. OS = M * G * (XM * sin(XF * x) + YM * sin(YF * y) + ZM * cos(ZF * z)) OS is the output scalar; M represents the maximum value; G represents the Gaussian; XM, YM, and ZM are the X, Y, and Z magnitude values; and XF, YF, and ZF are the X, Y, and Z frequency values. If a two-dimensional extent is specified, the resulting image will be displayed. If a three-dimensional extent is used, then the bounding box of the volume will be displayed.

paraview.simple.WindBladereader(*input, **params)

WindBlade/Firetec is a simulation dealing with the effects of wind on wind turbines or on the spread of fires. It produces three outputs - a StructuredGrid for the wind data fields, a StructuredGrid for the ground topology, and a PolyData for turning turbine blades. The input file (.wind) opened by the WindBlade reader is an ASCII description of the data files expected. Data is accumulated by the simulation processor and is written one file per time step. WindBlade can deal with topology if a flag is turned on and expects (x,y) data for the ground. It also can deal with turning wind turbines from other time step data files which gives polygon positions of segments of the blades and data for each segment. This is a distributed reader.

paraview.simple.WriteAnimationGeometry(filename, view=None)

Save the animation geometry from a specific view to a file specified. The animation geometry is written out as a PVD file.

Parameters

• filename (str) – The file path of the PVD file to write.

• view (View proxy) – The view holding the geometry that should be saved. Optional, defaults to the active view if possible.

paraview.simple.XDMFReader(*input, **params)

The XDMF reader reads

files in XDMF format. The expected file extension is .xmf. Metadata is stored in the XDMF file using an XML format, and large attribute arrays are stored in a corresponding HDF5 file. The output may be unstructured grid, structured grid, or rectiliner grid. See http://www.xdmf.org for a description of the file format. This is a distributed reader.

paraview.simple.XMLHierarchicalBoxDataWriter(*input, **params)

(DEPRECATED) Writer to write a hierarchical box in a xml-based vtk data file. Can be used for parallel writing as well as serial writing. This is deprecated. Use XMLUniformGridAMRWriter instead.

paraview.simple.XMLHierarchicalBoxDatareader(*input, **params)

The XML Hierarchical Box Data reader reads VTK’s XML-based file format containing a vtkHierarchicalBoxDataSet. The expected file extensions is either .vthb or .vth.

paraview.simple.XMLImageDataReader(*input, **params)

The XML Image

Data reader reads the VTK XML image data file format. The standard extension is .vti. This reader also supports file series.

paraview.simple.XMLImageDataWriter(*input, **params)

Writer to write image data in a xml-based vtk data file. Cannot be used for parallel writing.

paraview.simple.XMLMultiBlockDataReader(*input, **params)

The XML

Multiblock Data reader reads the VTK XML multiblock data file format. XML multiblock data files are meta-files that point to a list of serial VTK XML files. When reading in parallel, this reader will distribute sub-blocks among processors. The expected file extensions are .vtm and .vtmb.

paraview.simple.XMLMultiBlockDataWriter(*input, **params)

Writer to write a multiblock dataset in a xml-based vtk data file. Can be used for parallel writing as well as serial writing.

paraview.simple.XMLPHyperTreeGridWriter(*input, **params)

Writer to write hyper tree grid in a xml-based vtk data file. Can be used for parallel writing.

paraview.simple.XMLPImageDataWriter(*input, **params)

Writer to write image data in a xml-based vtk data file. Can be used for parallel writing.

paraview.simple.XMLPPartitionedDataSetWriter(*input, **params)

Write a vtkPartitionedDataSet to a xml-based vtk data file.

paraview.simple.XMLPPolyDataWriter(*input, **params)

Writer to write polydata in a xml-based vtk data file. Can be used for parallel writing.

paraview.simple.XMLPRectilinearGridWriter(*input, **params)

Writer to write rectilinear grid in a xml-based vtk data file. Can be used for parallel writing.

paraview.simple.XMLPStructuredGridWriter(*input, **params)

Writer to write structured grid in a xml-based vtk data file. Can be used for parallel writing.

paraview.simple.XMLPTableWriter(*input, **params)

Writer to write table in a xml-based vtk data file. Can be used for parallel writing.

paraview.simple.XMLPUnstructuredGridWriter(*input, **params)

Writer to write unstructured grid in a xml-based vtk data file. Can be used for parallel writing.

paraview.simple.XMLPVAnimationWriter(*input, **params)

Internal writer proxy used when saving animation geometry

to save all parts of the current source to the file with pieces spread across the server processes.

paraview.simple.XMLPVDWriter(*input, **params)

Writer to write ParaView data files (pvd). It is used to save all pieces of a source/filter to a file with pieces spread across the server processes.

paraview.simple.XMLPartitionedDataSetCollectionWriter(*input, **params)

Write a vtkPartitionedDataSetCollection to a xml-based vtk data file.

paraview.simple.XMLPartitionedDatasetCollectionReader(*input, **params)

The XML

Partitioned Dataset Collection reader reads the VTK XML Partitioned Dataset Collection file format. XML partitioned dataset collection files are meta-files that point to a list of serial VTK XML files. When reading in parallel, this reader will distribute sub-blocks among processors. The expected file extensions are .vtpc.

paraview.simple.XMLPartitionedDatasetReader(*input, **params)

The XML

Partitioned Dataset reader reads the VTK XML Partitioned Dataset file format. XML partitioned dataset files are meta-files that point to a list of serial VTK XML files. When reading in parallel, this reader will distribute sub-blocks among processors. The expected file extensions are .vtpd.

paraview.simple.XMLPartitionedHyperTreeGridReader(*input, **params)

The XML Partitioned Hyper Tree Grid reader reads the partitioned VTK htg data file format. It reads the partitioned format’s summary file and then the associated VTK XML htg data files. The expected file extension is .phtg. This reader also supports file series.

paraview.simple.XMLPartitionedImageDataReader(*input, **params)

The XML Partitioned Image Data reader reads the partitioned VTK image data file format. It reads the partitioned format’s summary file and then the associated VTK XML image data files. The expected file extension is .pvti. This reader also supports file series.

paraview.simple.XMLPartitionedPolydataReader(*input, **params)

The

XML Partitioned Polydata reader reads the partitioned VTK polydata file format. It reads the partitioned format’s summary file and then the associated VTK XML polydata files. The expected file extension is .pvtp. This reader also supports file series.

paraview.simple.XMLPartitionedRectilinearGridReader(*input, **params)

The XML Partitioned Rectilinear Grid reader reads the partitioned VTK rectilinear grid file format. It reads the partitioned format’s summary file and then the associated VTK XML rectilinear grid files. The expected file extension is .pvtr. This reader also supports file series.

paraview.simple.XMLPartitionedStructuredGridReader(*input, **params)

The XML Partitioned Structured Grid reader reads the partitioned VTK structured grid data file format. It reads the partitioned format’s summary file and then the associated VTK XML structured grid data files. The expected file extension is .pvts. This reader also supports file series.

paraview.simple.XMLPartitionedTableReader(*input, **params)

The XML Partitioned Table reader reads the partitioned VTK table data file format. It reads the partitioned format’s summary file and then the associated VTK XML table data files. The expected file extension is .pvtt. This reader also supports file series.

paraview.simple.XMLPartitionedUnstructuredGridReader(*input, **params)

The XML Partitioned Unstructured Grid reader reads the partitioned VTK unstructured grid data file format. It reads the partitioned format’s summary file and then the associated VTK XML unstructured grid data files. The expected file extension is .pvtu. This reader also supports file series.

paraview.simple.XMLPolyDataReader(*input, **params)

The XML Polydata

reader reads the VTK XML polydata file format. The standard extension is .vtp. This reader also supports file series.

paraview.simple.XMLPolyDataWriter(*input, **params)

Writer to write poly data in a xml-based vtk data file. Cannot be used for parallel writing.

paraview.simple.XMLRectilinearGridReader(*input, **params)

The

XML Rectilinear Grid reader reads the VTK XML rectilinear grid data file format. The standard extension is .vtr. This reader also supports file series.

paraview.simple.XMLRectilinearGridWriter(*input, **params)

Writer to write rectilinear grid in a xml-based vtk data file. Cannot be used for parallel writing.

paraview.simple.XMLStructuredGridReader(*input, **params)

The

XML Structured Grid reader reads the VTK XML structured grid data file format. The standard extension is .vts. This reader also supports file series.

paraview.simple.XMLStructuredGridWriter(*input, **params)

Writer to write structured grid in a xml-based vtk data file. Cannot be used for parallel writing.

paraview.simple.XMLTableReader(*input, **params)

The XML Table

reader reads the VTK XML Table file format. The standard extension is .vtt. This reader also supports file series.

paraview.simple.XMLTableWriter(*input, **params)

Writer to write a table in a xml-based vtk data file. Cannot be used for parallel writing.

paraview.simple.XMLUniformGridAMRReader(*input, **params)

This reader reads Overlapping and Non-Overlapping AMR datasets in VTK XML format. This reader reads the newer version of the format. For version 1.0 and less, use XMLHierarchicalBoxDataReader. The expected file extensions is either .vthb or .vth.

paraview.simple.XMLUniformGridAMRWriter(*input, **params)

Writer to write an AMR data-set (overlapping/non-overlapping) in a xml-based vtk data file. Can be used for parallel writing as well as serial writing.

paraview.simple.XMLUnstructuredGridReader(*input, **params)

The XML Unstructured Grid reader reads the VTK XML unstructured grid data file format. The standard extension is .vtu. This reader also supports file series.

paraview.simple.XMLUnstructuredGridWriter(*input, **params)

Writer to write unstructured grid in a xml-based vtk data file. Cannot be used for parallel writing.

paraview.simple.XYZReader(*input, **params)

The XYZ reader

reads XYZ molecular data files. The expected file extension is .xyz. The output of this reader is a vtkMolecule

paraview.simple.XdmfWriter(*input, **params)

Writer to write

data in eXtensible Data Model and Format *(XDMF) files.

paraview.simple.YieldCriteria(*input, **params)

This filter computes yield criteria such as the Tresca or Von Mises criteria for 2D and 3D tensors. Principal values and directions can also be included in the output. The principal vectors can be scaled by their corresponding principal values.

paraview.simple.YoungsMaterialInterface(*input, **params)

Computes linear material interfaces in 2D or 3D mixed cells produced by Eulerian or ALE simulation codes

paraview.simple.a2DGlyph(*input, **params)

The 2D Glyph source is used

for generating a family of 2D glyphs, each of which lies in the x-y plane. The output of the 2D Glyph source is polygonal data.

paraview.simple.a3DText(*input, **params)

The 3D Text source

displays a text string as polygonal data.

paraview.simple.glTFReader(*input, **params)

The glTF reader reads a glTF file.

paraview.simple.openPMDReader(*input, **params)

Reader for openPMD files.

paraview.simple.proSTARSTARCDReader(*input, **params)

ProStarReader creates an unstructured grid dataset. It reads .cel/.vrt files stored in proSTAR (STARCD) ASCII format.

paraview.simple.spcthhistoryreader(*input, **params)

Modules

• simple.animation Module
• simple.camera Module
• simple.catalyst Module
• simple.color Module
• simple.compatibility Module
• simple.deprecated Module
• simple.io Module
• simple.layout Module
• simple.light Module
• simple.link Module
• simple.plugin Module
• simple.proxy Module
• simple.rendering Module
• simple.selection Module
• simple.session Module
• simple.setting Module
• simple.texture Module
• simple.version Module
• simple.view Module
• simple.widget Module

Subpackages

• example Package
  • Modules
    • simple.example.demo1 Module
    • simple.example.demo2 Module
    • simple.example.trame Module