Provided by: mayavi2_4.5.0-1_amd64 bug


       mayavi2 - A scientific visualization package for 2-D and 3-D data


       mayavi2 [options] [args]

       Where  arg1,  arg2  etc.  are  optional  file  names  that  correspond  to  saved  Mayavi2
       visualizations (filename.mv2),  Mayavi2 scripts ( and any  data  file  formats
       that Mayavi supports.


       Mayavi2 is a tool for 2-D and 3-D scientific visualization. Features of Mayavi2 include:

       *      Visualization of scalar and vector data in 2 and 3 dimensions

       *      Easy scriptability using Python

       *      Easy extendability via sources, components, modules, and data filters

       *      Reading several file formats: VTK (legacy and XML), PLOT3D, etc.

       *      Saving of visualizations

       *      Saving rendered visualization in a variety of image formats.



       This  prints  all  the  available  command line options and exits.  Also available through


       This prints the Mayavi version on the command line  and  exits.   Also  available  through

       -z filename.mv2

       This  loads  a  previously  saved  Mayavi2  visualization.   Also  available through --viz
       filename.mv2 or --visualization filename.mv2.

       -d datafile.*

       Opens any of the supported data file formats or a  non-file  related  data  source.   This
       includes  VTK  file  formats  (*.vtk,  *.xml,  *.vt[i,p,r,s,u],  *.pvt[i,p,r,s,u]),  VRML2
       (*.wrl), 3D Studio (*.3ds), PLOT3D (*.xyz), STL, BYU, RAW,  PLY,  PDB,  SLC,  FACET,  OBJ,
       AVSUCD  (*.inp), GAMBIT (*.neu), Exodus (*.exii), PNG, JPEG, BMP, PNM, DCM, DEM, MHA, MHD,
       MINC, XIMG, TIFF, and various others that are supported.  datafile.* can also be a  source
       object  not  associated  with a file, for example ParametricSurface or PointLoad will load
       the corresponding data sources into Mayavi.  Also available through --data.

       -m module-name

       A module is an object that actually visualizes the data.  The given module-name is  loaded
       in  the current ModuleManager.  The module name must be a valid one if not you will get an
       error message.

       If a module is specified as 'package.sub.module.SomeModule' then the  module  (SomeModule)
       is imported from 'package.sub.module'.  Standard modules provided with mayavi2 do not need
       the full path specification.  For example:

              mayavi2 -d data.vtk -m Outline -m m2_user_modules.TestModule

       In this example 'Outline' is a standard module and  'm2_user_modules.TestModule'  is  some
       user  defined  module.   See  MAYAVI2  MODULES  section  below  for  an exhaustive list of
       available modules.  Also available through --module.

       -f filter-name

       A filter is an object that filters out the data in some  way  or  the  other.   The  given
       filter-name  is  loaded with respect to the current source/filter object.  The filter name
       must be a valid one if not you will get an error message.

       If  the  filter  is  specified  as   'package.sub.filter.SomeFilter'   then   the   filter
       (`SomeFilter`)  is  imported  from  'package.sub.filter'.   Standard modules provided with
       mayavi2 do not need the full path specification.  For example:

              mayavi2 -d data.vtk -f ExtractVectorNorm -f m2_user_filters.TestFilter

       In this example 'ExtractVectorNorm' is a standard filter and  'm2_user_filters.TestFilter'
       is some user defined filter.

       See  MAYAVI2  FILTERS  section  below  for  an  exhaustive list of available filters. Also
       available through --filter.


       Starts  up  a  new  module  manager  on  the  Mayavi  pipeline.  Also  available   through


       Creates a new window/scene. Any options passed after this will apply to this newly created
       scene.  Also available through --new-window.


       Runs the mayavi2 test suite and exits.  If run as  such,  this  runs  both  the  TVTK  and
       Mayavi2  unittests.   If  any additional arguments are passed they are passed along to the
       test runner.  So this may be used to run other tests as well.  For example:

              mayavi2 -t enthought.persistence

       This will run just the tests inside  the  enthought.persistence  package.   You  can  also
       specify a directory with test files to run with this, for example:

              mayavi2 -t relative_path_to/integrationtests/mayavi

       will run the integration tests from the mayavi sources.   Also available through --test.

       -x script-file

       This executes the given script in a namespace where we guarantee that the name 'mayavi' is
       Mayavi's script instance -- just like in the embedded Python interpreter.  Also  available
       through --exec

       WARNING:  Note that this uses `execfile`, so please note that this can be dangerous if the
       script does something nasty!

       -s python-expression

       Execute the expression on the last created object.  For example, if  the  previous  object
       was   a   module,   and  we  want  to  set  the  color  of  that  object  one  can  do  -s
       " =  (1,0,0)".   One  should  use  quotes  for  the  expression.  Also
       available with --set.  For example:

               mayavi2 -d ParametricSurface -m Outline \
                -s " = (1,0,0)" \
                -s "'test.png', size=(800, 800))"

       WARNING: Note that this uses `exec`, so please note that this can be dangerous!


       Axes   Draws simple axes.

              A  contour  grid plane module. This module lets one take a slice of input grid data
              and view contours of the data.

              A custom grid plane with a lot more flexibility than GridPlane module.

              This filter clips the dataset in a area.  The area can be defined interactively  as
              a box, a sphere...

       Glyph  Displays  different  types  of  glyphs oriented and colored as per scalar or vector
              data at the input points.

              A simple grid plane module.

              A module that integrates through a tensor field to generate a hyperstreamline.  The
              integration  is  along  the  maximum  eigenvector  and  the  cross  section  of the
              hyperstreamline is defined by the two other eigenvectors. Thus  the  shape  of  the
              hyperstreamline   is   "tube-like",   with  the  cross  section  being  elliptical.
              Hyperstreamlines are used to visualize tensor fields.

              A simple module to view image data efficiently.

              A simple module to view image data.

              A module that allows the user to make contours of input point data.

       Labels Allows a user to label the current dataset or  the  current  actor  of  the  active

              Creates  a  small  axes  on the side that indicates the position of the co-ordinate
              axes and thereby marks the orientation of the scene. Requires VTK-4.5 and above.

              A module that draws an outline for the given data.

              Takes a cut plane of any input data set using an implicit plane and plots the  data
              with optional contouring and scalar warping.

              This  module  takes  a slice of the unstructured grid data and shows the cells that
              intersect or touch the slice.

              Allows the user to draw streamlines for given vector data.  This  supports  various
              types  of  seed  objects  (line, sphere, plane and point seeds). It also allows the
              user to draw ribbons or tubes and further supports different types  of  interactive
              modes of calculating the streamlines.

              Draws a grid-conforming outline for structured grids.

              Draws a surface for any input dataset with optional contouring.

              Displays  tensor  glyphs  oriented  and colored as per scalar or vector data at the
              input points.

       Text   This module allows the user to place text on the screen.

              Takes an arbitrary slice of the input data using an implicit cut plane  and  places
              glyphs  according  to the vector field data. The glyphs may be colored using either
              the vector magnitude or the scalar attributes.

              Displays different types of glyphs oriented and colored as per vector data  at  the
              input  points.  This  is  merely a convenience module that is entirely based on the
              Glyph module.

       Volume The  Volume  module  visualizes  scalar  fields  using   volumetric   visualization

              Takes an arbitrary slice of the input data using an implicit cut plane and warps it
              according to the vector field data. The scalars are displayed on the warped surface
              as colors.


              Computes derivatives from input point scalar and vector data and produces cell data
              on the gradients.  Can be used to approximately calcuate the vorticity for example.

              Transforms cell attribute data to point data by averaging the cell  data  from  the
              cells at the point.

              A  contour  filter that wraps around the Contour component to generate iso-surfaces
              on any input dataset.

              This class represents a cut plane that can be used to slice  through  any  dataset.
              It   also   provides  a  3D  widget  interface  to  position  and  move  the  slice

              Creates scalar data corresponding to the elevation of the points along a line.

              Performs a 2D Delaunay triangulation.

              Performs a 3D Delaunay triangulation.

              This filter extracts cell edges from any input data.

              Allows a user to select a part of a structured grid.

              Wraps the TVTK ExtractTensorComponents filter to extract components from  a  tensor

              Allows a user to select a part of an unstructured grid.

              Computes  the  norm  (Eucliedean)  of  the input vector data (with optional scaling
              between [0, 1]). This is useful when the input data has vector input but no  scalar
              data for the magnitude of the vectors.

              Wraps  the  TVTK  ExtractVectorComponents filter to extract components of a vector.
              This is useful for analysing individual components of a vector data.

              This filter splat points into a volume with an elliptical, Gaussian distribution.

              Selectively passes the input points downstream. This can be used to  subsample  the
              input  points.  Note  that  this  does  not pass geometry data, this means all grid
              information is lost.

              Approximates a height field (image data) with a triangle mesh, keeping  the  number
              of triangles minimum.

              A  filter  that  can  be used to change the origin, spacing and extents of an input
              image dataset without changing the data itself.

              A filter that can be used to probe any dataset using a Structured  Points  dataset.
              The filter also allows one to convert the scalar data to an unsigned short array so
              that the scalars can be used for volume visualization.

              Does the inverse of the CellToPointData filter.

              Computes normals from input data. This gives meshes  a  smoother  appearance.  This
              should work for any input dataset. Note: this filter is called "Compute Normals" in
              Mayavi2 GUI (Visualize/Filters/Compute Normals).

              Reduce triangles in a mesh, forming a good approximation of the original mesh.

              A filter that allows a user to select one among several of the outputs of  a  given
              input.  This is typically very useful for a multi-block data source.

              This  filter  lets  a  user  set  the  active  data attribute (scalars, vectors and
              tensors) on a VTK dataset.  This is particularly useful if you need to do something
              like compute contours of one scalar on the contour of another scalar.

              Create  triangle  strips  and/or  poly-lines.  Useful  for  regularizing  broken up
              surfaces, such as those created by the Tube filter.  .

              A simple filter that thresholds on input data.

              Performs a linear transformation to input data.

              Converts  input   polygons   and   triangle   strips   to   triangles   using   the
              tvtk.TriangleFilter  class.   This is useful when you have a downstream filter that
              only processes triangles.

       Tube   Turns lines into tubes.

              This filter lets the user define their own filter dynamically/interactively.  It is
              like FilterBase but allows a user to specify the class without writing any code.

              This  filter computes the vorticity of an input vector field.  For convenience, the
              filter allows one to optionally pass-through the given  input  vector  field.   The
              filter  also  allows  the  user  to  show  the  component  of the vorticity along a
              particular cartesian co-ordinate axes.  It produces point data on output  which  is
              ready to visualize.

              Warps  the  input  data  along  a  particular  direction  (either  the normals or a
              specified direction) with a scale specified by the local scalar value.  Useful  for
              making carpet plots.

              Warps  the  input  data  along  a  the point vector attribute scaled as per a scale
              factor.  Useful for showing flow profiles or displacements.


              mayavi2 -d heart.vtk -m  Axes  -m  Outline  -m  GridPlane  -m  ContourGridPlane  -m
              mayavi2 -d fire_ug.vtu -m Axes -m Outline -m VectorCutPlane -f MaskPoints -m Glyph

       In   the   above   examples,   heart.vti  and  fire_ug.vtu  VTK  files  can  be  found  in
       /usr/share/doc/mayavi2/examples/data.           The           examples           directory
       (/usr/share/doc/mayavi2/examples/ on Debian) provides several useful examples.


       Mayavi   was  originally  developed  by  Prabhu  Ramachandran.   Many  people  have  later
       contributed to it.

       More information on Mayavi2 can be obtained from