/[escript]/trunk/doc/user/pyvisi.tex
ViewVC logotype

Diff of /trunk/doc/user/pyvisi.tex

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 886 by jongui, Thu Nov 2 01:34:58 2006 UTC revision 1078 by jongui, Thu Apr 5 06:18:47 2007 UTC
# Line 1  Line 1 
1  \chapter{The module \pyvisi}  \chapter{The module \pyvisi}
2  \label{PYVISI CHAP}  \label{PYVISI CHAP}
3    \declaremodule{extension}{esys.pyvisi}
4    \modulesynopsis{Python Visualization Interface}
5    
6  \declaremodule{extension}{pyvisi}  \section{Introduction}
7  \modulesynopsis{Python visualization interface}  \pyvisi is a Python module that is used to generate 2D and 3D visualization
8    for escript and its PDE solvers: finley and bruce. This module provides
9  \pyvisi provides an easy to use interface to the \VTK visualization  an easy to use interface to the \VTK library (\VTKUrl). There are three
10  tool. \pyvisi provides the following modules:  approaches of rendering an object. (1) Online - object is rendered on-screen
11    with interaction (i.e. zoom and rotate) capability, (2) Offline - object is
12  \begin{itemize}  rendered off-screen (no window comes up) and (3) Display - object is rendered
13  \item \Scene: Shows a scene in which components are to be displayed.  on-screen but with no interaction capability (able to produce on-the-fly
14  \item \Image: Shows an image.  animation). All three approaches have the option to save the rendered object
15  \item \Text: Shows some 2D text.  as an image.
16  \item \DataCollector: Deals with data for visualization.  
17  \item \Camera: Controls the camera manipulation.  The following points outline the general guidelines when using \pyvisi:
18  \item \Light: Controls the light manipulation.  
19  \item \Map: Shows a scalar field by color on the domain surface.  \begin{enumerate}
20  \item \MapOnPlane: Shows a scalar field by color on a given plane.  \item Create a \Scene instance, a window in which objects are to be rendered on.
21  \item \MapOnClip: Shows a scalar field by color on a given clip.  \item Create a data input instance (i.e. \DataCollector or \ImageReader), which
22  \item \MapOnScalarClip: Shows a scalar field by color on a give scalar clip.  reads and loads the source data for visualization.
23  \item \Arrows: Shows a vector field by arrows.  \item Create a data visualization instance (i.e. \Map, \Velocity, \Ellipsoid,
24  \item \ArrowsOnPlane: Shows a vector field by arrows on a given plane.  \Contour, \Carpet, \StreamLine or \Image), which proccesses and manipulates the
25  \item \ArrowsOnClip: Shows a vector field by arrows on a given clip.  source data.
26  \item \IsoSurface: Shows a scalar field for a given value by  \item Create a \Camera or \Light instance, which controls the viewing angle and
27  an isosurface.  lighting effects.
28  \item \IsoSurfaceOnPlane: Shows a scalar field for a given value by  \item Render the object using either the Online, Offline or Display approach.
29  an isosurfaceon a given plane.  \end{enumerate}
30  \item \IsoSurfaceOnClip: Shows a scalar field for a given vlaue by  \begin{center}
31  an isosurface on a given clip.  \begin{math}
32  \item \Contour: Shows a scalar field by contour surfaces.  scene \rightarrow data input \rightarrow data visualization \rightarrow
33  \item \ContourOnPlane: Shows a scalar field by contour surfaces on  camera/light \rightarrow render
34  a given plane.  \end{math}
35  \item \ContourOnClip: Shows a scalar field by contour surfaces on  \end{center}
36  a given clip.  
37  \item \TensorC: Shows a tensor field by ellipsoids.  The sequence in which instances are created is very important due to
38  \item \TensorOnPlane: Shows a tensor field by ellipsoids on  to the dependencies among them. For example, a data input instance must
39  a given plane.  be created BEFORE a data visualization instance, because the source data must
40  \item \TensorOnClip: Shows a tensor field by ellipsoids on a given clip.  be specified before it can be manipulated. If the sequence is switched,
41  \item \StreamLines: Shows the path of particles in a vector field.  the program will throw an error. Similarly, a camera and light instance must
42  \item \Carpet: Shows a scalar field as plane deformated along  be created AFTER a data input instance because the camera and light instance
43  the plane normal.  calculates their position based on the source data. If the sequence is switched,
44  \item \Position: Defines the x,y and z coordinates rendered object.  the programthe will throw an error .
45  \item \Transform: Defines the orientation of rendered object.  
46  \item \Style: Defines the style of text.  \section{\pyvisi Classes}
47  \item \BlueToRed: Defines a map spectrum from blue to red.  The following subsections give a brief overview of the important classes
48  \item \RedToBlue: Defines a map spectrum from red to blue.  and some of their corresponding methods. Please refer to \ReferenceGuide for
49  \item \Plane: Defines the cutting/clipping of rendered objects.  full details.
50  \end{itemize}  
51    
52  \section{\Scene class}  %#############################################################################
53  \begin{classdesc}{Scene}{renderer, x_size = 500, y_size = 500}  
54  A \Scene object creates a window onto which objects are to be displayed.  
55  \end{classdesc}  \subsection{Scene Classes}
56    This subsection details the instances used to setup the viewing environment.
57  The following are the methods available:  
58  \begin{methoddesc}[Scene]{saveImage}{image_name}  \subsubsection{\Scene class}
59  Save the rendered object as an image off-screen.  
60  \end{methoddesc}  \begin{classdesc}{Scene}{renderer = Renderer.ONLINE, num_viewport = 1,
61    x_size = 1152, y_size = 864}
62  \begin{methoddesc}[Scene]{render}{}  A scene is a window in which objects are to be rendered on. Only
63  Render the object on-screen.  one scene needs to be created. However, a scene may be divided into four
64  \end{methoddesc}  smaller windows called viewports (if needed). Each viewport can
65    render a different object.
 The following is a sample code using the \Scene class:  
 \verbatiminput{../examples/driverscene.py}  
   
 \section{\Image class}  
 \begin{classdesc}{Image}{scene, format}  
 An \Image object shows an image.  
 \end{classdesc}  
   
 The following is the method available:  
 \begin{methoddesc}[Image]{setFileName}{file_name}  
 Set the file name.  
 \end{methoddesc}  
   
 The following is a sample code using the \Image class.  
 \fig{fig:image.1} shows the corresponding output.  
 \verbatiminput{../examples/driverimage.py}  
   
 \begin{figure}[ht]  
 \begin{center}  
 \includegraphics[width=40mm]{figures/Image}  
 \end{center}  
 \caption{Image}  
 \label{fig:image.1}  
 \end{figure}  
   
 \section{\Text class}  
 \begin{classdesc}{Text}{scene}  
 A \Text object shows 2D text.  
66  \end{classdesc}  \end{classdesc}
67    
68  The following are the methods available:  The following are some of the methods available:
69  \begin{methoddesc}[Text]{setText}{text}  \begin{methoddesc}[Scene]{setBackground}{color}
70  Set the text.  Set the background color of the scene.
 \end{methoddesc}  
   
 \begin{methoddesc}[Text]{setPosition}{x_coor, y_coor}  
 Set the display position of the text.  
 \end{methoddesc}  
   
 \begin{methoddesc}[Text]{setStyle}{style}  
 Set the style of the text.  
71  \end{methoddesc}  \end{methoddesc}
72    
73  The following is a sample code using the \Text class.  \begin{methoddesc}[Scene]{render}{image_name = None}
74  \fig{fig:text.1} shows the corresponding output.  Render the object using either the Online, Offline or Display mode.
 \verbatiminput{../examples/drivertext.py}  
   
 \begin{figure}[ht]  
 \begin{center}  
 \includegraphics[width=40mm]{figures/Text}  
 \end{center}  
 \caption{2D text}  
 \label{fig:text.1}  
 \end{figure}  
   
 \section{\DataCollector class}  
 \begin{classdesc}{DataCollector}{scene, outline = True, cube_axes = False}  
 A \DataCollector object deals with the data for visualization.  
 \end{classdesc}  
   
 The following are the methods available:  
 \begin{methoddesc}[DataCollector]{setFileName}{file_name}  
 Set the file name from which data is to be read.  
75  \end{methoddesc}  \end{methoddesc}
76    
77  The following is a sample code using the \DataCollector class.  \subsubsection{\Camera class}
 \fig{fig:datacollector.1} shows the corresponding output.  
 \verbatiminput{../examples/driverdatacollector.py}  
78    
79  \begin{figure}[ht]  \begin{classdesc}{Camera}{scene, data_collector, viewport = Viewport.SOUTH_WEST}
80  \begin{center}  A camera controls the display angle of the rendered object and one is
81  \includegraphics[width=40mm]{figures/DataCollector}  usually created for a \Scene. However, if a \Scene has four viewports, then a
82  \end{center}  separate camera may be created for each viewport.
 \caption{Datacollector generating an outline with cube axes.}  
 \label{fig:datacollector.1}  
 \end{figure}  
   
 \section{\Camera class}  
 \begin{classdesc}{Camera}{scene, data_collector}  
 A \Camera object controls the camera's settings.  
83  \end{classdesc}  \end{classdesc}
84    
85  The following are some of the methods available:  The following are some of the methods available:
# Line 157  Rotate the camera to the left and right. Line 96  Rotate the camera to the left and right.
96  \end{methoddesc}  \end{methoddesc}
97    
98  \begin{methoddesc}[Camera]{elevation}{angle}  \begin{methoddesc}[Camera]{elevation}{angle}
99  Rotate the camera to the top and bottom.  Rotate the camera to the top and bottom (only between -90 and 90).
 \end{methoddesc}  
   
 \begin{methoddesc}[Camera]{roll}{angle}  
 Roll the camera to the left and right.  
100  \end{methoddesc}  \end{methoddesc}
101    
102  \begin{methoddesc}[Camera]{backView}{}  \begin{methoddesc}[Camera]{backView}{}
103  View the back of the rendered object.  Rotate the camera to view the back of the rendered object.
104  \end{methoddesc}  \end{methoddesc}
105    
106  \begin{methoddesc}[Camera]{topView}{}  \begin{methoddesc}[Camera]{topView}{}
107  View the top of the rendered object.  Rotate the camera to view the top of the rendered object.
108  \end{methoddesc}  \end{methoddesc}
109    
110  \begin{methoddesc}[Camera]{bottomView}{}  \begin{methoddesc}[Camera]{bottomView}{}
111  View the bottom of the rendered object.  Rotate the camera to view the bottom of the rendered object.
112  \end{methoddesc}  \end{methoddesc}
113    
114  \begin{methoddesc}[Camera]{leftView}{}  \begin{methoddesc}[Camera]{leftView}{}
115  View the left side of the rendered object.  Rotate the camera to view the left side of the rendered object.
116  \end{methoddesc}  \end{methoddesc}
117    
118  \begin{methoddesc}[Camera]{rightView}{}  \begin{methoddesc}[Camera]{rightView}{}
119  View the right side of the rendered object.  Rotate the camera to view the right side of the rendered object.
120  \end{methoddesc}  \end{methoddesc}
121    
122  \begin{methoddesc}[Camera]{isometricView}{}  \begin{methoddesc}[Camera]{isometricView}{}
123  View the isometric side of the rendered object.  Rotate the camera to view the isometric angle of the rendered object.
124  \end{methoddesc}  \end{methoddesc}
125    
126  The following is a sample code using the \Camera class.  \begin{methoddesc}[Camera]{dolly}{distance}
127  \fig{fig:camera.1} shows the corresponding output.  Move the camera towards (greater than 1) and away (less than 1) from
128  \verbatiminput{../examples/drivercamera.py}  the rendered object.
129    \end{methoddesc}
130    
131  \begin{figure}[ht]  \subsubsection{\Light class}
 \begin{center}  
 \includegraphics[width=30mm]{figures/Camera}  
 \end{center}  
 \caption{Camera manipulation}  
 \label{fig:camera.1}  
 \end{figure}  
132    
133  \section{\Light class}  \begin{classdesc}{Light}{scene, data_collector, viewport = Viewport.SOUTH_WEST}
134  \begin{classdesc}{Light}{scene, data_collector}  A light controls the lighting for the rendered object and works in
135  A \Light object controls the light's settings.  a similar way to \Camera.
136  \end{classdesc}  \end{classdesc}
137    
138  The following are the methods available:  The following are some of the methods available:
139  \begin{methoddesc}[Light]{setColor}{color}  \begin{methoddesc}[Light]{setColor}{color}
140  Set the color of the light.  Set the light color.
141  \end{methoddesc}  \end{methoddesc}
142    
143  \begin{methoddesc}[Light]{setFocalPoint}{position}  \begin{methoddesc}[Light]{setFocalPoint}{position}
# Line 218  Set the focal point of the light. Line 148  Set the focal point of the light.
148  Set the position of the light.  Set the position of the light.
149  \end{methoddesc}  \end{methoddesc}
150    
151  \begin{methoddesc}[Light]{setIntensity}{intesity}  \begin{methoddesc}[Light]{setAngle}{elevation = 0, azimuth = 0}
152  Set the intensity (brightness) of the light.  An alternative to set the position and focal point of the light by using the
153    elevation and azimuth.
154  \end{methoddesc}  \end{methoddesc}
155    
 The following is a sample code using the \Light class.  
 \fig{fig:light.1} shows the corresponding output.  
 \verbatiminput{../examples/driverlight.py}  
156    
157  \begin{figure}[ht]  %##############################################################################
 \begin{center}  
 \includegraphics[width=40mm]{figures/Light}  
 \end{center}  
 \caption{Light}  
 \label{fig:light.1}  
 \end{figure}  
158    
 \section{\Map class}  
 \begin{classdesc}{Map}{scene, data_collector, lut = None}  
 A \Map object shows a scalar field by color on the domain surface.  
 \end{classdesc}  
159    
160  The following is a sample code using the \Map class.  \subsection{Input Classes}
161  \fig{fig:map.1} shows the corresponding output.  This subsection details the instances used to read and load the source data
162  \verbatiminput{../examples/drivermap.py}  for visualization.
163    
164  \begin{figure}[ht]  \subsubsection{\DataCollector class}
 \begin{center}  
 \includegraphics[width=40mm]{figures/Map}  
 \end{center}  
 \caption{Surface map}  
 \label{fig:map.1}  
 \end{figure}  
165    
166  \section{\MapOnPlane class}  \begin{classdesc}{DataCollector}{source = Source.XML}
167  \begin{classdesc}{MapOnPlane}{scene, data_collector, transform, lut = None}  A data collector is used to read data from an XML file or from
168  A \MapOnPlane object show a scalar field by color on a given plane.  an escript object directly.
169  \end{classdesc}  \end{classdesc}
170    
171  The following is a sample code using the \MapOnPlane class.  The following are some of the methods available:
172  \fig{fig:maponplane.1} shows the corresponding output.  \begin{methoddesc}[DataCollector]{setFileName}{file_name}
173  \verbatiminput{../examples/drivermaponplane.py}  Set the XML file name to read.
174    \end{methoddesc}
175    
176    \begin{methoddesc}[DataCollector]{setData}{**args}
177    Create data using the \textless name\textgreater=\textless data\textgreater
178    pairing. Assumption is made that the data will be given in the
179    appropriate format.
180    
181  \begin{figure}[ht]  BUG: Reading source data directly from an escript object is NOT
182  \begin{center}  work properly. Therefore this method should NOT be used at this stage.
183  \includegraphics[width=40mm]{figures/MapOnPlane}  \end{methoddesc}
 \end{center}  
 \caption{Surface map on a plane}  
 \label{fig:maponplane.1}  
 \end{figure}  
184    
185  \section{\MapOnClip class}  \begin{methoddesc}[DataCollector]{setActiveScalar}{scalar}
186  \begin{classdesc}{MapOnClip}{scene, data_collector, transform, lut = None}  Specify the scalar field to load.
187  A \MapOnClip object show a scalar field by color on a given clip.  \end{methoddesc}
 \end{classdesc}  
188    
189  The following is a sample code using the \MapOnClip class.  \begin{methoddesc}[DataCollector]{setActiveVector}{vector}
190  \fig{fig:maponclip.1} shows the corresponding output.  Specify the vector field to load.
191  \verbatiminput{../examples/drivermaponclip.py}  \end{methoddesc}
192    
193  \begin{figure}[ht]  \begin{methoddesc}[DataCollector]{setActiveTensor}{tensor}
194  \begin{center}  Specify the tensor field to load.
195  \includegraphics[width=40mm]{figures/MapOnClip}  \end{methoddesc}
 \end{center}  
 \caption{Surface map on a clip}  
 \label{fig:maponclip.1}  
 \end{figure}  
196    
197  \section{\MapOnScalarClip class}  \subsubsection{\ImageReader class}
198  \begin{classdesc}{MapOnScalarClip}{scene, data_collector, lut = None}  
199  A \MapOnScalarClip object show a scalar field by color on a given scalar clip.  \begin{classdesc}{ImageReader}{format}
200    An image reader is used to read data from an image in a variety of formats.
201  \end{classdesc}  \end{classdesc}
202    
203  The following is a sample code using the \MapOnScalarClip class.  The following are some of the methods available:
204  \fig{fig:maponscalarclip.1} shows the corresponding output.  \begin{methoddesc}[ImageReader]{setImageName}{image_name}
205  \verbatiminput{../examples/drivermaponscalarclip.py}  Set the image name to be read.
206    \end{methoddesc}
207    
208  \begin{figure}[ht]  \subsubsection{\TextTwoD class}
 \begin{center}  
 \includegraphics[width=40mm]{figures/MapOnScalarClip}  
 \end{center}  
 \caption{Surface map on a scalar clip}  
 \label{fig:maponscalarclip.1}  
 \end{figure}  
209    
210  \section{\Arrows class}  \begin{classdesc}{Text2D}{scene, text, viewport = Viewport.SOUTH_WEST}
211  \begin{classdesc}{Arrows}{scene, data_collector, lut = None}  A two-dimensional text is used to annotate the rendered object
212  A \Arrows object shows a vector field by arrows.  (i.e. adding titles, authors and labels).
213  \end{classdesc}  \end{classdesc}
214    
215  The following are the methods available:  The following are some of the methods available:
216  \begin{methoddesc}[Arrows]{setVectorMode}{vector_mode}  \begin{methoddesc}[Text2D]{setFontSize}{size}
217  Set the arrows vector mode.  Set the 2D text size.
218  \end{methoddesc}  \end{methoddesc}
219    
220  \begin{methoddesc}[Arrows]{setScaleMode}{scale_mode}  \begin{methoddesc}[Text2D]{boldOn}{}
221  Set the arrows scale mode.  Bold the 2D text.
222  \end{methoddesc}  \end{methoddesc}
223    
224  \begin{methoddesc}[Arrows]{setScaleFactor}{scale_factor}  \begin{methoddesc}[Text2D]{setColor}{color}
225  Set the arrows scale factor.  Set the color of the 2D text.
226  \end{methoddesc}  \end{methoddesc}
227    
228  \begin{methoddesc}[Arrows]{setColorMode}{color_mode}  Including methods from \ActorTwoD.
 Set the arrows color mode.  
 \end{methoddesc}  
229    
 The following is a sample code using the \Arrows class.  
 \fig{fig:arrows.1} shows the corresponding output.  
 \verbatiminput{../examples/driverarrows.py}  
230    
231  \begin{figure}[ht]  %##############################################################################
232  \begin{center}  
233  \includegraphics[width=40mm]{figures/Arrows}  
234  \end{center}  \subsection{Data Visualization Classes}
235  \caption{Arrows}  This subsection details the instances used to process and manipulate the source
236  \label{fig:arrows.1}  data.
 \end{figure}  
237    
238  \section{\ArrowsOnPlane class}  One point to note is that the source can either be point or cell data. If the
239  \begin{classdesc}{ArrowsOnPlane}{scene, data_collector, transform, lut = None}  source is cell data, a conversion to point data may or may not be
240  A \ArrowsOnPlane object shows a vector field by arrows on a given plane.  required, in order for the object to be rendered correctly.
241    If a conversion is needed, the 'cell_to_point' flag (see below) must be set to
242    'True', otherwise 'False' (which is the default).
243    
244    \subsubsection{\Map class}
245    
246    \begin{classdesc}{Map}{scene, data_collector,
247    viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR, cell_to_point = False,
248    outline = True}
249    Class that shows a scalar field on a domain surface. The domain surface
250    can either be colored or grey-scaled, depending on the lookup table used.
251  \end{classdesc}  \end{classdesc}
252    
253  The following is a sample code using the \ArrowsOnPlane class.  The following are some of the methods available:\\
254  \fig{fig:arrowsonplane.1} shows the corresponding output.  Methods from \ActorThreeD.
 \verbatiminput{../examples/driverarrowsonplane.py}  
255    
256  \begin{figure}[ht]  \subsubsection{\MapOnPlaneCut class}
 \begin{center}  
 \includegraphics[width=40mm]{figures/ArrowsOnPlane}  
 \end{center}  
 \caption{Arrows on a plane}  
 \label{fig:arrowsonplane.1}  
 \end{figure}  
257    
258  \section{\ArrowsOnClip class}  \begin{classdesc}{MapOnPlaneCut}{scene, data_collector,
259  \begin{classdesc}{ArrowsOnClip}{scene, data_collector, transform, lut = None}  viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR, cell_to_point = False,
260  A \ArrowsOnClip object shows a vector field by arrows on a given clip.  outline = True}
261    This class works in a similar way to \Map, except that it shows a scalar
262    field on a plane. The plane can be translated and rotated along the X, Y and
263    Z axes.
264  \end{classdesc}  \end{classdesc}
265    
266  The following is a sample code using the \ArrowsOnClip class.  The following are some of the methods available:\\
267  \fig{fig:arrowsonclip.1} shows the corresponding output.  Methods from \ActorThreeD and \Transform.
 \verbatiminput{../examples/driverarrowsonclip.py}  
268    
269  \begin{figure}[ht]  \subsubsection{\MapOnPlaneClip class}
 \begin{center}  
 \includegraphics[width=40mm]{figures/ArrowsOnClip}  
 \end{center}  
 \caption{Arrows on a clip}  
 \label{fig:arrowsonclip.1}  
 \end{figure}  
270    
271    \begin{classdesc}{MapOnPlaneClip}{scene, data_collector,
272    viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR, cell_to_point = False,
273    outline = True}
274    This class works in a similar way to \MapOnPlaneCut, except that it shows a
275    scalar field clipped using a plane.
276    \end{classdesc}
277    
278    The following are some of the methods available:\\
279    Methods from \ActorThreeD, \Transform and \Clipper.
280    
281    \subsubsection{\MapOnScalarClip class}
282    
283  \section{\IsoSurface class}  \begin{classdesc}{MapOnScalarClip}{scene, data_collector,
284  \begin{classdesc}{IsoSurface}{scene, data_collector, lut = None}  viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR, cell_to_point = False,
285  An \IsoSurface object shows a scalar field for a given value by an isosurface.  outline = True}
286    This class works in a similar way to \Map, except that it shows a scalar
287    field clipped using a scalar value.
288  \end{classdesc}  \end{classdesc}
289    
290  The following is the method available:  The following are some of the methods available:\\
291    Methods from \ActorThreeD and \Clipper.
292    
293  \begin{methoddesc}[IsoSurface]{setValue}{contour_number, value}  \subsubsection{\Velocity class}
 Set the contour number and value.  
 \end{methoddesc}  
294    
295  The following is a sample code using the \IsoSurface class.  \begin{classdesc}{Velocity}{scene, data_collector,
296  \fig{fig:isosurface.1} shows the corresponding output.  viewport = Viewport.SOUTH_WEST, color_mode = ColorMode.VECTOR,
297  \verbatiminput{../examples/driverisosurface.py}  arrow = Arrow.TWO_D, lut = Lut.COLOR, cell_to_point = False, outline = True}
298    Class that shows a vector field using arrows. The arrows can either be
299    colored or grey-scaled, depending on the lookup table used. If the arrows
300    are colored, there are two possible coloring modes, either using vector data or
301    scalar data. Similarly, there are two possible types of arrows, either
302    using two-dimensional or three-dimensional.
303    \end{classdesc}
304    
305  \begin{figure}[ht]  The following are some of the methods available:\\
306  \begin{center}  Methods from \ActorThreeD, \GlyphThreeD and \MaskPoints.
 \includegraphics[width=40mm]{figures/IsoSurface}  
 \end{center}  
 \caption{IsoSurface}  
 \label{fig:isosurface.1}  
 \end{figure}  
   
 \section{\IsoSurfaceOnPlane class}  
 \begin{classdesc}{IsoSurfaceOnPlane}{scene, data_collector, transform,  
 lut = None}  
 An \IsoSurfaceOnPlane object shows a scalar field for a given value  
 by an isosurface on a given plane.  
 \end{classdesc}  
   
 The following is a sample code using the \IsoSurfaceOnPlane class.  
 \fig{fig:isosurfaceonplane.1} shows the corresponding output.  
 \verbatiminput{../examples/driverisosurfaceonplane.py}  
307    
308  \begin{figure}[ht]  \subsubsection{\VelocityOnPlaneCut class}
 \begin{center}  
 \includegraphics[width=40mm]{figures/IsoSurfaceOnPlane}  
 \end{center}  
 \caption{IsoSurface on a plane}  
 \label{fig:isosurfaceonplane.1}  
 \end{figure}  
   
 \section{\IsoSurfaceOnClip class}  
 \begin{classdesc}{IsoSurfaceOnClip}{scene, data_collector, transform,  
 lut = None}  
 An \IsoSurfaceOnClip object shows a scalar field for a given value  
 by an isosurface on a given clip.  
 \end{classdesc}  
   
 The following is a sample code using the \IsoSurfaceOnClip class.  
 \fig{fig:isosurfaceonclip.1} shows the corresponding output.  
 \verbatiminput{../examples/driverisosurfaceonclip.py}  
309    
310  \begin{figure}[ht]  \begin{classdesc}{VelocityOnPlaneCut}{scene, data_collector,
311  \begin{center}  arrow = Arrow.TWO_D, color_mode = ColorMode.VECTOR,
312  \includegraphics[width=40mm]{figures/IsoSurfaceOnClip}  viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR,
313  \end{center}  cell_to_point = False, outline = True}
314  \caption{IsoSurface on a clip}  This class works in a similar way to \MapOnPlaneCut, except that
315  \label{fig:isosurfaceonclip.1}  it shows a vector field using arrows on a plane.
 \end{figure}  
   
 \section{\Contour class}  
 \begin{classdesc}{Contour}{scene, data_collector, lut = None}  
 A \Contour object shows a scalar field contour surfaces.  
316  \end{classdesc}  \end{classdesc}
317    
318  The following is the method available:  The following are some of the methods available:\\
319  \begin{methoddesc}[Contour]{generateValues}{number_contours, min_range,  Methods from \ActorThreeD, \GlyphThreeD, \Transform and \MaskPoints.
 max_range}  
 Generate the specified number of contours within the specified range.  
 \end{methoddesc}  
320    
321  The following is a sample code using the \Contour class.  \subsubsection{\VelocityOnPlaneClip class}
 \fig{fig:contour.1} shows the corresponding output.  
 \verbatiminput{../examples/drivercontour.py}  
322    
323  \begin{figure}[ht]  \begin{classdesc}{VelocityOnPlaneClip}{scene, data_collector,
324  \begin{center}  arrow = Arrow.TWO_D, color_mode = ColorMode.VECTOR,
325  \includegraphics[width=40mm]{figures/Contour}  viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR,
326  \end{center}  cell_to_point = False, online = True}
327  \caption{Contour}  This class works in a similar way to \MapOnPlaneClip, except that it shows a
328  \label{fig:contour.1}  vector field using arrows clipped using a plane.
329  \end{figure}  \end{classdesc}
330    
331  \section{\ContourOnPlane class}  The following are some of the methods available:\\
332  \begin{classdesc}{ContourOnPlane}{scene, data_collector, transform, lut = None}  Methods from \ActorThreeD, \GlyphThreeD, \Transform, \Clipper and
333  A \ContourOnPlane object shows a scalar field contour surfaces on a given plane.  \MaskPoints.
334    
335    \subsubsection{\Ellipsoid class}
336    
337    \begin{classdesc}{Ellipsoid}{scene, data_collector,
338    viewport = Viewport = SOUTH_WEST, lut = Lut.COLOR, outline = True}
339    Class that shows a tensor field using ellipsoids. The ellipsoids can either be
340    colored or grey-scaled, depending on the lookup table used.
341  \end{classdesc}  \end{classdesc}
342    
343  The following is a sample code using the \ContourOnPlane class.  The following are some of the methods available:\\
344  \fig{fig:contouronplane.1} shows the corresponding output.  Methods from \ActorThreeD, \Sphere, \TensorGlyph and \StructuredPoints.
 \verbatiminput{../examples/drivercontouronplane.py}  
345    
346  \begin{figure}[ht]  \subsubsection{\EllipsoidOnPlaneCut class}
 \begin{center}  
 \includegraphics[width=40mm]{figures/ContourOnPlane}  
 \end{center}  
 \caption{Contour on a plane}  
 \label{fig:contouronplane.1}  
 \end{figure}  
347    
348  \section{\ContourOnClip class}  \begin{classdesc}{EllipsoidOnPlaneCut}{scene, data_collector,
349  \begin{classdesc}{ContourOnClip}{scene, data_collector, transform, lut = None}  viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR, outline = True}
350  A \ContourOnClip object shows a scalar field contour surfaces on a given clip.  This class works in a similar way to \MapOnPlaneCut, except that it shows
351    a tensor field using ellipsoids cut using a plane.
352  \end{classdesc}  \end{classdesc}
353    
354  The following is a sample code using the \ContourOnClip class.  The following are some of the methods available:\\
355  \fig{fig:contouronclip.1} shows the corresponding output.  Methods from \ActorThreeD, \Sphere, \TensorGlyph, \Transform and
356  \verbatiminput{../examples/drivercontouronclip.py}  \StructuredPoints.
357    
358  \begin{figure}[ht]  \subsubsection{\EllipsoidOnPlaneClip class}
 \begin{center}  
 \includegraphics[width=40mm]{figures/ContourOnClip}  
 \end{center}  
 \caption{Contour on a clip}  
 \label{fig:contouronclip.1}  
 \end{figure}  
359    
360  \section{\TensorC class}  \begin{classdesc}{EllipsoidOnPlaneClip}{scene, data_collector,
361  \begin{classdesc}{Tensor}{scene, data_collector, lut = None}  viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR, outline = True}
362  A \TensorC object shows a tensor field by ellipsoids.  This class works in a similar way to \MapOnPlaneClip, except that it shows a
363    tensor field using ellipsoids clipped using a plane.
364  \end{classdesc}  \end{classdesc}
365            
366    The following are some of the methods available:\\
367    Methods from \ActorThreeD, \Sphere, \TensorGlyph, \Transform, \Clipper
368    and \StructuredPoints.
369    
370  The following are the methods available:  \subsubsection{\Contour class}
 \begin{methoddesc}[Tensor]{setThetaResolution}{resolution}  
 Set the number of points in the longitude direction.  
 \end{methoddesc}  
371    
372  \begin{methoddesc}[Tensor]{setPhiResolution}{resolution}  \begin{classdesc}{Contour}{scene, data_collector,
373  Set the number of points in the latitude direction.  viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR, cell_to_point = False,
374  \end{methoddesc}  outline = True}
375    Class that shows a scalar field by contour surfaces. The contour surfaces can
376    either be colored or grey-scaled, depending on the lookup table used. This
377    class can also be used to generate iso surfaces.
378    \end{classdesc}
379    
380  \begin{methoddesc}[Tensor]{setScaleFactor}{scale_factor}  The following are some of the methods available:\\
381  Set the tensor scale factor.  Methods from \ActorThreeD and \ContourModule.
 \end{methoddesc}  
382    
383  \begin{methoddesc}[Tensor]{setMaxScaleFactor}{max_scale_factor}  \subsubsection{\ContourOnPlaneCut class}
 Set the maximum allowable scale factor.  
 \end{methoddesc}  
384    
385  The following is a sample code using the \TensorC class.  \begin{classdesc}{ContourOnPlaneCut}{scene, data_collector,
386  \fig{fig:tensor.1} shows the corresponding output.  viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR, cell_to_point = False,
387  \verbatiminput{../examples/drivertensor.py}  outline = True}
388    This class works in a similar way to \MapOnPlaneCut, except that it shows a
389    scalar field by contour surfaces on a plane.
390    \end{classdesc}
391    
392  \begin{figure}[ht]  The following are some of the methods available:\\
393  \begin{center}  Methods from \ActorThreeD, \ContourModule and \Transform.
 \includegraphics[width=40mm]{figures/Tensor}  
 \end{center}  
 \caption{Tensor}  
 \label{fig:tensor.1}  
 \end{figure}  
394    
395  \section{\TensorOnPlane class}  \subsubsection{\ContourOnPlaneClip class}
396  \begin{classdesc}{TensorOnPlane}{scene, data_collector, transform, lut = None}  
397  A \TensorOnPlane object shows a tensor field by ellipsoids on a given plane.  \begin{classdesc}{ContourOnPlaneClip}{scene, data_collector,
398    viewport = Viewport.SOUTH_WEST, lut = Lut.COLOR, cell_to_point = False,
399    outline = True}
400    This class works in a similar way to \MapOnPlaneClip, except that it shows a
401    scalar field by contour surfaces clipped using a plane.
402  \end{classdesc}  \end{classdesc}
403    
404  The following is a sample code using the \TensorOnPlane class.  The following are some of the methods available:\\
405  \fig{fig:tensoronplane.1} shows the corresponding output.  Methods from \ActorThreeD, \ContourModule, \Transform and \Clipper.
 \verbatiminput{../examples/drivertensoronplane.py}  
406    
407  \begin{figure}[ht]  \subsubsection{\StreamLine class}
 \begin{center}  
 \includegraphics[width=40mm]{figures/TensorOnPlane}  
 \end{center}  
 \caption{Tensor on a plane}  
 \label{fig:tensoronplane.1}  
 \end{figure}  
408    
409  \section{\TensorOnClip class}  \begin{classdesc}{StreamLine}{scene, data_collector,
410  \begin{classdesc}{TensorOnClip}{scene, data_collector, transform, lut = None}  viewport = Viewport.SOUTH_WEST, color_mode = ColorMode.VECTOR, lut = Lut.COLOR,
411  A \TensorOnClip object shows a tensor field by ellipsoids on a given clip.  outline = True}
412    Class that shows the direction of particles of a vector field using streamlines.
413    The streamlines can either be colored or grey-scaled, depending on the lookup
414    table used. If the streamlines are colored, there are two possible coloring
415    modes, either using vector data or scalar data.
416  \end{classdesc}  \end{classdesc}
417    
418  The following is a sample code using the \TensorOnClip class.  The following are some of the methods available:\\
419  \fig{fig:tensoronclip.1} shows the corresponding output.  Methods from \ActorThreeD, \PointSource, \StreamLineModule and \Tube.
 \verbatiminput{../examples/drivertensoronclip.py}  
420    
421  \begin{figure}[ht]  \subsubsection{\Carpet class}
422  \begin{center}  
423  \includegraphics[width=40mm]{figures/TensorOnClip}  \begin{classdesc}{Carpet}{scene, data_collector,
424  \end{center}  viewport = Viewport.Viewport.SOUTH_WEST, warp_mode = WarpMode.SCALAR,
425  \caption{Tensor on a clip}  lut = Lut.COLOR, outline = True}
426  \label{fig:tensoronclip.1}  This class works in a similar way to \MapOnPlaneCut, except that it shows a
427  \end{figure}  scalar field on a plane deformated (warp) along the normal. The plane can
428    either be colored or grey-scaled, depending on the lookup table used.
429    Similarly, the plane can be deformated either using scalar data or vector data.
430    \end{classdesc}
431    
432    The following are some of the methods available:\\
433    Methods from \ActorThreeD, \Warp and \Transform.
434    
435  \section{\StreamLines class}  \subsubsection{\Image class}
436  \begin{classdesc}{StreamLines}{scene, data_collector, lut = None}  
437  A \StreamLines object show the path of particles (within a specified cloud  \begin{classdesc}{Image}{scene, image_reader, viewport = Viewport.SOUTH_WEST}
438  of points) in a vector field.  Class that displays an image which can be scaled (upwards and downwards). The
439    image can also be translated and rotated along the X, Y and Z axes.
440  \end{classdesc}  \end{classdesc}
441    
442  The following are the methods available:  The following are some of the methods available:\\
443  \begin{methoddesc}[StreamLines]{setCloudRadius}{radius}  Methods from \ActorThreeD, \PlaneSource and \Transform.
444  Set the radius for the cloud of points.  
445    
446    %##############################################################################
447    
448    
449    \subsection{Coordinate Classes}
450    This subsection details the instances used to position the rendered object.
451    
452    \begin{classdesc}{LocalPosition}{x_coor, y_coor}
453    Class that defines the local positioning coordinate system (2D).
454    \end{classdesc}
455    
456    \begin{classdesc}{GlobalPosition}{x_coor, y_coor, z_coor}
457    Class that defines the global positioning coordinate system (3D).
458    \end{classdesc}
459    
460    
461    %##############################################################################
462    
463    
464    \subsection{Supporting Classes}
465    This subsection details the supporting classes inherited by the data
466    visualization classes. These supporting
467    
468    \subsubsection{\ActorThreeD class}
469    
470    The following are some of the methods available:
471    
472    \begin{methoddesc}[Actor3D]{setOpacity}{opacity}
473    Set the opacity (transparency) of the 3D actor.
474  \end{methoddesc}  \end{methoddesc}
475    
476  \begin{methoddesc}[StreamLines]{setCenter}{position}  \begin{methoddesc}[Actor3D]{setColor}{color}
477  Set the center for the cloud of points.  Set the color of the 3D actor.
478  \end{methoddesc}  \end{methoddesc}
479    
480  \begin{methoddesc}[StreamLines]{setNumberOfPoints}{points}  \begin{methoddesc}[Actor3D]{setRepresentationToWireframe}{}
481  Set the number of points to generate for the cloud of points.  Set the representation of the 3D actor to wireframe.
482  \end{methoddesc}  \end{methoddesc}
483    
484  \begin{methoddesc}[StreamLines]{setMaximumPropagationTime}{time}  \subsubsection{\ActorTwoD class}
485  Set the maximum length for the streamlines in unit of time.  
486    The following are some of the methods available:
487    
488    \begin{methoddesc}[Actor2D]{setPosition}{position}
489    Set the position (XY) of the 2D actor. Default position is the lower left hand
490    corner of the window / viewport.
491  \end{methoddesc}  \end{methoddesc}
492    
493  \begin{methoddesc}[StreamLines]{setStreamLinesSize}{stream_lines_size}  \subsubsection{\Clipper class}
494  Set the size of the steamlines.  
495    The following are some of the methods available:
496    
497    \begin{methoddesc}[Clipper]{setInsideOutOn}{}
498    Clips one side of the rendered object.
499  \end{methoddesc}  \end{methoddesc}
500    
501  \begin{methoddesc}[StreamLines]{setAccuracy}{accuracy}  \begin{methoddesc}[Clipper]{setInsideOutOff}{}
502  Set the accuracy for the streamlines.  Clips the other side of the rendered object.
503  \end{methoddesc}  \end{methoddesc}
504    
505  \begin{methoddesc}[StreamLines]{setIntegrationToBothDirections}{}  \begin{methoddesc}[Clipper]{setClipValue}{value}
506  Set the integration to occur in both directions.  Set the scalar clip value.
507  \end{methoddesc}  \end{methoddesc}
508    
509  \begin{methoddesc}[StreamLines]{setTubeRadius}{radius}  \subsubsection{\ContourModule class}
510  Set the minimum radius of the tube.  
511    The following are some of the methods available:
512    
513    \begin{methoddesc}[ContourModule]{generateContours}{contours,
514    lower_range = None, upper_range = None}
515    Generate the specified number of contours within the specified range.
516  \end{methoddesc}  \end{methoddesc}
517    
518  \begin{methoddesc}[StreamLines]{setNumberOfSides}{sides}  \subsubsection{\GlyphThreeD class}
519  Set the number of sides for the tube.  
520    The following are some of the methods available:
521    
522    \begin{methoddesc}[Glyph3D]{setScaleModeByVector}{}
523    Set the 3D glyph to scale according to the vector data.
524  \end{methoddesc}  \end{methoddesc}
525    
526  \begin{methoddesc}[StreamLines]{setVaryRadiusByVector}{}  \begin{methoddesc}[Glyph3D]{setScaleModeByScalar}{}
527  Set the variation of the tube radius with vector data.  Set the 3D glyph to scale according to the scalar data.
528  \end{methoddesc}  \end{methoddesc}
529    
530  The following is a sample code using the \StreamLines class.  \begin{methoddesc}[Glyph3D]{setScaleFactor}{scale_factor}
531  \fig{fig:streamlines.1} shows the corresponding output.  Set the 3D glyph scale factor.
532  \verbatiminput{../examples/driverstreamlines.py}  \end{methoddesc}
533    
534  \begin{figure}[ht]  \subsubsection{\TensorGlyph class}
 \begin{center}  
 \includegraphics[width=40mm]{figures/StreamLines}  
 \end{center}  
 \caption{StreamLines}  
 \label{fig:streamlines.1}  
 \end{figure}  
535    
536  \section{\Carpet class}  The following are some of the methods available:
 \begin{classdesc}{Carpet}{scene, data_collector, transform, lut = None,  
 deform = None}  
 A \Carpet object shows a scalar/vector field as a plane deformated along  
 the plane normal.  
 \end{classdesc}  
537    
538  The following is the method available:  \begin{methoddesc}[TensorGlyph]{setScaleFactor}{scale_factor}
539  \begin{methoddesc}[Carpet]{setScaleFactor}{scale_factor}  Set the scale factor for the tensor glyph.
 Set the displancement scale factor.  
540  \end{methoddesc}  \end{methoddesc}
541    
542  The following is a sample code using the \Carpet class.  \subsubsection{\PlaneSource class}
 \fig{fig:carpet.1} shows the corresponding output.  
 \verbatiminput{../examples/drivercarpet.py}  
543    
544  \begin{figure}[ht]  The following are some of the methods available:
 \begin{center}  
 \includegraphics[width=40mm]{figures/Carpet}  
 \end{center}  
 \caption{Carpet}  
 \label{fig:carpet.1}  
 \end{figure}  
545    
546    \begin{methoddesc}[PlaneSource]{setPoint1}{position}
547    Set the first point from the origin of the plane source.
548    \end{methoddesc}
549    
550  \section{\Position class}  \begin{methoddesc}[PlaneSource]{setPoint2}{position}
551  \begin{classdesc}{Position}{x_coor, y_coor, z_coor}  Set the second point from the origin of the plane source.
552  A \Position object defines the x, y and z coordinates of rendered object.  \end{methoddesc}
 \end{classdesc}  
553    
554  \section{\Transform class}  \subsubsection{\PointSource class}
 \begin{classdesc}{Transform}{}  
 A \Transform object defines the orientation of rendered object.  
 \end{classdesc}  
555    
556  The following are some of the methods available:  The following are some of the methods available:
557  \begin{methoddesc}[Transform]{translate}{x_offset, y_offset, z_offset}  
558  Translate the rendered object along the x, y and z-axes.  \begin{methoddesc}[PointSource]{setPointSourceRadius}{radius}
559    Set the radius of the sphere.
560  \end{methoddesc}  \end{methoddesc}
561    
562  \begin{methoddesc}[Transform]{rotateX}{angle}  \begin{methoddesc}[PointSource]{setPointSourceNumberOfPoints}{points}
563  Rotate the rendered object along the x-axis.  Set the number of points to generate within the sphere (the larger the
564    number of points, the more streamlines are generated).
565  \end{methoddesc}  \end{methoddesc}
566    
567  \begin{methoddesc}[Transform]{rotateY}{angle}  \subsubsection{\StructuredPoints class}
568  Rotate the rendered object along the y-axis.  
569    The following are some of the methods available:
570    
571    \begin{methoddesc}[StructuredPoints]{setDimension}{x, y, z}
572    Set the dimension on the x, y and z axes. The smaller the dimension,
573    the more points are populated.
574  \end{methoddesc}  \end{methoddesc}
575    
576  \begin{methoddesc}[Transform]{rotateZ}{angle}  \subsubsection{\Sphere class}
577  Rotate the rendered object along the z-axis.  
578    The following are some of the methods available:
579    
580    \begin{methoddesc}[Sphere]{setThetaResolution}{resolution}
581    Set the theta resolution of the sphere.
582  \end{methoddesc}  \end{methoddesc}
583    
584  \begin{methoddesc}[Transform]{xyPlane}{offset = 0}  \begin{methoddesc}[Sphere]{setPhiResolution}{resolution}
585  Set the plane orthogonal to the z-axis.  Set the phi resoluton of the sphere.
586  \end{methoddesc}  \end{methoddesc}
587    
588  \begin{methoddesc}[Transform]{yzPlane}{offset = 0}  \subsubsection{\StreamLineModule class}
589  Set the plane orthogonal to the x-axis.  
590    The following are some of the methods available:
591    
592    \begin{methoddesc}[StreamLineModule]{setMaximumPropagationTime}{time}
593    Set the maximum length of the streamline expressed in elapsed time.
594  \end{methoddesc}  \end{methoddesc}
595    
596  \begin{methoddesc}[Transform]{xzPlane}{offset = 0}  \begin{methoddesc}[StreamLineModule]{setIntegrationToBothDirections}{}
597  Set the plane orthogonal to the y-axis.  Set the integration to occur both sides: forward (where the streamline
598    goes) and backward (where the streamline came from).
599  \end{methoddesc}  \end{methoddesc}
600    
601  \section{\Style class}  \subsubsection{\Transform class}
 \begin{classdesc}{Style}{}  
 A \Style object defines the style of text.  
 \end{classdesc}  
602    
603  The following are the methods available:  \begin{methoddesc}[Transform]{translate}{x_offset, y_offset, z_offset}
604  \begin{methoddesc}[Style]{setFontFamily}{family}  Translate the rendered object along the x, y and z-axes.
605  Set the font family (i.e. Times)  \end{methoddesc}
606    
607    \begin{methoddesc}[Transform]{rotateX}{angle}
608    Rotate the plane along the x-axis.
609  \end{methoddesc}  \end{methoddesc}
610    
611  \begin{methoddesc}[Style]{boldOn}{}  \begin{methoddesc}[Transform]{rotateY}{angle}
612  Bold the text.  Rotate the plane along the y-axis.
613  \end{methoddesc}  \end{methoddesc}
614    
615  \begin{methoddesc}[Style]{italicOn}{}  \begin{methoddesc}[Transform]{rotateZ}{angle}
616  Italize the text.  Rotate the plane along the z-axis.
617  \end{methoddesc}  \end{methoddesc}
618    
619  \begin{methoddesc}[Style]{shadowOn}{}  \begin{methoddesc}[Transform]{setPlaneToXY}{offset = 0}
620  Apply shadows on the text.  Set the plane orthogonal to the z-axis.
621  \end{methoddesc}  \end{methoddesc}
622    
623  \begin{methoddesc}[Style]{setColor}{}  \begin{methoddesc}[Transform]{setPlaneToYZ}{offset = 0}
624  Set the text color.  Set the plane orthogonal to the x-axis.
625  \end{methoddesc}  \end{methoddesc}
626    
627  \section{\BlueToRed class}  \begin{methoddesc}[Transform]{setPlaneToXZ}{offset = 0}
628  \begin{classdesc}{BlueToRed}{}  Set the plane orthogonal to the y-axis.
629  A \BlueToRed object defines a map spectrum from blue to red.  \end{methoddesc}
 \end{classdesc}  
630    
631  \section{\RedToBlue class}  \subsubsection{\Tube class}
 \begin{classdesc}{RedToBlue}{}  
 A \RedToBlue object defines a map spectrum from red to blue.  
 \end{classdesc}  
632    
633  \section{\Plane class}  \begin{methoddesc}[Tube]{setTubeRadius}{radius}
634  The following are the methods available:  Set the radius of the tube.
 \begin{methoddesc}[Plane]{setPlaneOrigin}{position}  
 Set the plane origin  
635  \end{methoddesc}  \end{methoddesc}
636    
637  \begin{methoddesc}[Plane]{setPlaneNormal}{position}  \begin{methoddesc}[Tube]{setTubeRadiusToVaryByVector}{}
638  Set the plane normal  Set the radius of the tube to vary by vector data.
639  \end{methoddesc}  \end{methoddesc}
640    
641  \begin{methoddesc}[Plane]{setValue}{clipping_value}  \begin{methoddesc}[Tube]{setTubeRadiusToVaryByScalar}{}
642  Set the clipping value  Set the radius of the tube to vary by scalar data.
643  \end{methoddesc}  \end{methoddesc}
644    
645  \begin{methoddesc}[Plane]{setInsideOutOn}{}  \subsubsection{\Warp class}
 Set the clipping to inside out  
 \end{methoddesc}  
646    
647  \begin{methoddesc}[Plane]{setInsideOutOff}{}  \begin{methoddesc}[Warp]{setScaleFactor}{scale_factor}
648  Disable the inside out clipping  Set the displacement scale factor.
649  \end{methoddesc}  \end{methoddesc}
650    
 \section{Additional Notes}  
 The following is a sample code rendering multiple planes.  
 \fig{fig:multipleplanes.1} shows the corresponding output.  
 \verbatiminput{../examples/drivermultipleplanes.py}  
651    
652  \begin{figure}[ht]  \section{Online Rendering Mechnism}
 \begin{center}  
 \includegraphics[width=60mm]{figures/MultiplePlanes}  
 \end{center}  
 \caption{Multiple planes}  
 \label{fig:multipleplanes.1}  
 \end{figure}  
653    
 The following is a sample code rendering multiple cuts.  
 \verbatiminput{../examples/drivermultiplecuts.py}  
654    
655    
656  The following is a sample code rendering multiple reads from multiple files.  same word on rendering, off-line, on-line, how to rotate, zoom, close the window, ...
 \verbatiminput{../examples/drivermultiplereads.py}  
657    
658    %==============================================
659    \section{How to Make a Movie}

Legend:
Removed from v.886  
changed lines
  Added in v.1078

  ViewVC Help
Powered by ViewVC 1.1.26