
\begin{DoxyItemize}
\item \hyperlink{vtkcommon_vtkabstractarray}{vtk\-Abstract\-Array}  
\item \hyperlink{vtkcommon_vtkabstracttransform}{vtk\-Abstract\-Transform}  
\item \hyperlink{vtkcommon_vtkamoebaminimizer}{vtk\-Amoeba\-Minimizer}  
\item \hyperlink{vtkcommon_vtkanimationcue}{vtk\-Animation\-Cue}  
\item \hyperlink{vtkcommon_vtkanimationscene}{vtk\-Animation\-Scene}  
\item \hyperlink{vtkcommon_vtkarray}{vtk\-Array}  
\item \hyperlink{vtkcommon_vtkarrayiterator}{vtk\-Array\-Iterator}  
\item \hyperlink{vtkcommon_vtkassemblynode}{vtk\-Assembly\-Node}  
\item \hyperlink{vtkcommon_vtkassemblypath}{vtk\-Assembly\-Path}  
\item \hyperlink{vtkcommon_vtkassemblypaths}{vtk\-Assembly\-Paths}  
\item \hyperlink{vtkcommon_vtkbitarray}{vtk\-Bit\-Array}  
\item \hyperlink{vtkcommon_vtkbox}{vtk\-Box}  
\item \hyperlink{vtkcommon_vtkboxmuellerrandomsequence}{vtk\-Box\-Mueller\-Random\-Sequence}  
\item \hyperlink{vtkcommon_vtkbyteswap}{vtk\-Byte\-Swap}  
\item \hyperlink{vtkcommon_vtkchararray}{vtk\-Char\-Array}  
\item \hyperlink{vtkcommon_vtkcollection}{vtk\-Collection}  
\item \hyperlink{vtkcommon_vtkcollectioniterator}{vtk\-Collection\-Iterator}  
\item \hyperlink{vtkcommon_vtkconditionvariable}{vtk\-Condition\-Variable}  
\item \hyperlink{vtkcommon_vtkcontourvalues}{vtk\-Contour\-Values}  
\item \hyperlink{vtkcommon_vtkcriticalsection}{vtk\-Critical\-Section}  
\item \hyperlink{vtkcommon_vtkcylindricaltransform}{vtk\-Cylindrical\-Transform}  
\item \hyperlink{vtkcommon_vtkdataarray}{vtk\-Data\-Array}  
\item \hyperlink{vtkcommon_vtkdataarraycollection}{vtk\-Data\-Array\-Collection}  
\item \hyperlink{vtkcommon_vtkdataarraycollectioniterator}{vtk\-Data\-Array\-Collection\-Iterator}  
\item \hyperlink{vtkcommon_vtkdataarrayselection}{vtk\-Data\-Array\-Selection}  
\item \hyperlink{vtkcommon_vtkdebugleaks}{vtk\-Debug\-Leaks}  
\item \hyperlink{vtkcommon_vtkdirectory}{vtk\-Directory}  
\item \hyperlink{vtkcommon_vtkdoublearray}{vtk\-Double\-Array}  
\item \hyperlink{vtkcommon_vtkdynamicloader}{vtk\-Dynamic\-Loader}  
\item \hyperlink{vtkcommon_vtkedgetable}{vtk\-Edge\-Table}  
\item \hyperlink{vtkcommon_vtkextentsplitter}{vtk\-Extent\-Splitter}  
\item \hyperlink{vtkcommon_vtkextenttranslator}{vtk\-Extent\-Translator}  
\item \hyperlink{vtkcommon_vtkfastnumericconversion}{vtk\-Fast\-Numeric\-Conversion}  
\item \hyperlink{vtkcommon_vtkfileoutputwindow}{vtk\-File\-Output\-Window}  
\item \hyperlink{vtkcommon_vtkfloatarray}{vtk\-Float\-Array}  
\item \hyperlink{vtkcommon_vtkfunctionparser}{vtk\-Function\-Parser}  
\item \hyperlink{vtkcommon_vtkfunctionset}{vtk\-Function\-Set}  
\item \hyperlink{vtkcommon_vtkgarbagecollector}{vtk\-Garbage\-Collector}  
\item \hyperlink{vtkcommon_vtkgaussianrandomsequence}{vtk\-Gaussian\-Random\-Sequence}  
\item \hyperlink{vtkcommon_vtkgeneraltransform}{vtk\-General\-Transform}  
\item \hyperlink{vtkcommon_vtkheap}{vtk\-Heap}  
\item \hyperlink{vtkcommon_vtkhomogeneoustransform}{vtk\-Homogeneous\-Transform}  
\item \hyperlink{vtkcommon_vtkidentitytransform}{vtk\-Identity\-Transform}  
\item \hyperlink{vtkcommon_vtkidlist}{vtk\-Id\-List}  
\item \hyperlink{vtkcommon_vtkidlistcollection}{vtk\-Id\-List\-Collection}  
\item \hyperlink{vtkcommon_vtkidtypearray}{vtk\-Id\-Type\-Array}  
\item \hyperlink{vtkcommon_vtkimplicitfunction}{vtk\-Implicit\-Function}  
\item \hyperlink{vtkcommon_vtkimplicitfunctioncollection}{vtk\-Implicit\-Function\-Collection}  
\item \hyperlink{vtkcommon_vtkinformation}{vtk\-Information}  
\item \hyperlink{vtkcommon_vtkinformationdataobjectkey}{vtk\-Information\-Data\-Object\-Key}  
\item \hyperlink{vtkcommon_vtkinformationdoublekey}{vtk\-Information\-Double\-Key}  
\item \hyperlink{vtkcommon_vtkinformationdoublevectorkey}{vtk\-Information\-Double\-Vector\-Key}  
\item \hyperlink{vtkcommon_vtkinformationidtypekey}{vtk\-Information\-Id\-Type\-Key}  
\item \hyperlink{vtkcommon_vtkinformationinformationkey}{vtk\-Information\-Information\-Key}  
\item \hyperlink{vtkcommon_vtkinformationinformationvectorkey}{vtk\-Information\-Information\-Vector\-Key}  
\item \hyperlink{vtkcommon_vtkinformationintegerkey}{vtk\-Information\-Integer\-Key}  
\item \hyperlink{vtkcommon_vtkinformationintegerpointerkey}{vtk\-Information\-Integer\-Pointer\-Key}  
\item \hyperlink{vtkcommon_vtkinformationintegervectorkey}{vtk\-Information\-Integer\-Vector\-Key}  
\item \hyperlink{vtkcommon_vtkinformationiterator}{vtk\-Information\-Iterator}  
\item \hyperlink{vtkcommon_vtkinformationkey}{vtk\-Information\-Key}  
\item \hyperlink{vtkcommon_vtkinformationkeyvectorkey}{vtk\-Information\-Key\-Vector\-Key}  
\item \hyperlink{vtkcommon_vtkinformationobjectbasekey}{vtk\-Information\-Object\-Base\-Key}  
\item \hyperlink{vtkcommon_vtkinformationobjectbasevectorkey}{vtk\-Information\-Object\-Base\-Vector\-Key}  
\item \hyperlink{vtkcommon_vtkinformationquadratureschemedefinitionvectorkey}{vtk\-Information\-Quadrature\-Scheme\-Definition\-Vector\-Key}  
\item \hyperlink{vtkcommon_vtkinformationrequestkey}{vtk\-Information\-Request\-Key}  
\item \hyperlink{vtkcommon_vtkinformationstringkey}{vtk\-Information\-String\-Key}  
\item \hyperlink{vtkcommon_vtkinformationstringvectorkey}{vtk\-Information\-String\-Vector\-Key}  
\item \hyperlink{vtkcommon_vtkinformationunsignedlongkey}{vtk\-Information\-Unsigned\-Long\-Key}  
\item \hyperlink{vtkcommon_vtkinformationvector}{vtk\-Information\-Vector}  
\item \hyperlink{vtkcommon_vtkinitialvalueproblemsolver}{vtk\-Initial\-Value\-Problem\-Solver}  
\item \hyperlink{vtkcommon_vtkinstantiator}{vtk\-Instantiator}  
\item \hyperlink{vtkcommon_vtkintarray}{vtk\-Int\-Array}  
\item \hyperlink{vtkcommon_vtklineartransform}{vtk\-Linear\-Transform}  
\item \hyperlink{vtkcommon_vtkloglookuptable}{vtk\-Log\-Lookup\-Table}  
\item \hyperlink{vtkcommon_vtklongarray}{vtk\-Long\-Array}  
\item \hyperlink{vtkcommon_vtklonglongarray}{vtk\-Long\-Long\-Array}  
\item \hyperlink{vtkcommon_vtklookuptable}{vtk\-Lookup\-Table}  
\item \hyperlink{vtkcommon_vtklookuptablewithenabling}{vtk\-Lookup\-Table\-With\-Enabling}  
\item \hyperlink{vtkcommon_vtkmath}{vtk\-Math}  
\item \hyperlink{vtkcommon_vtkmatrix3x3}{vtk\-Matrix3x3}  
\item \hyperlink{vtkcommon_vtkmatrix4x4}{vtk\-Matrix4x4}  
\item \hyperlink{vtkcommon_vtkmatrixtohomogeneoustransform}{vtk\-Matrix\-To\-Homogeneous\-Transform}  
\item \hyperlink{vtkcommon_vtkmatrixtolineartransform}{vtk\-Matrix\-To\-Linear\-Transform}  
\item \hyperlink{vtkcommon_vtkminimalstandardrandomsequence}{vtk\-Minimal\-Standard\-Random\-Sequence}  
\item \hyperlink{vtkcommon_vtkmultithreader}{vtk\-Multi\-Threader}  
\item \hyperlink{vtkcommon_vtkmutexlock}{vtk\-Mutex\-Lock}  
\item \hyperlink{vtkcommon_vtkobject}{vtk\-Object}  
\item \hyperlink{vtkcommon_vtkobjectbase}{vtk\-Object\-Base}  
\item \hyperlink{vtkcommon_vtkobjectfactory}{vtk\-Object\-Factory}  
\item \hyperlink{vtkcommon_vtkobjectfactorycollection}{vtk\-Object\-Factory\-Collection}  
\item \hyperlink{vtkcommon_vtkoutputwindow}{vtk\-Output\-Window}  
\item \hyperlink{vtkcommon_vtkoverrideinformation}{vtk\-Override\-Information}  
\item \hyperlink{vtkcommon_vtkoverrideinformationcollection}{vtk\-Override\-Information\-Collection}  
\item \hyperlink{vtkcommon_vtkparametricboy}{vtk\-Parametric\-Boy}  
\item \hyperlink{vtkcommon_vtkparametricconicspiral}{vtk\-Parametric\-Conic\-Spiral}  
\item \hyperlink{vtkcommon_vtkparametriccrosscap}{vtk\-Parametric\-Cross\-Cap}  
\item \hyperlink{vtkcommon_vtkparametricdini}{vtk\-Parametric\-Dini}  
\item \hyperlink{vtkcommon_vtkparametricellipsoid}{vtk\-Parametric\-Ellipsoid}  
\item \hyperlink{vtkcommon_vtkparametricenneper}{vtk\-Parametric\-Enneper}  
\item \hyperlink{vtkcommon_vtkparametricfigure8klein}{vtk\-Parametric\-Figure8\-Klein}  
\item \hyperlink{vtkcommon_vtkparametricfunction}{vtk\-Parametric\-Function}  
\item \hyperlink{vtkcommon_vtkparametricklein}{vtk\-Parametric\-Klein}  
\item \hyperlink{vtkcommon_vtkparametricmobius}{vtk\-Parametric\-Mobius}  
\item \hyperlink{vtkcommon_vtkparametricrandomhills}{vtk\-Parametric\-Random\-Hills}  
\item \hyperlink{vtkcommon_vtkparametricroman}{vtk\-Parametric\-Roman}  
\item \hyperlink{vtkcommon_vtkparametricsuperellipsoid}{vtk\-Parametric\-Super\-Ellipsoid}  
\item \hyperlink{vtkcommon_vtkparametricsupertoroid}{vtk\-Parametric\-Super\-Toroid}  
\item \hyperlink{vtkcommon_vtkparametrictorus}{vtk\-Parametric\-Torus}  
\item \hyperlink{vtkcommon_vtkperspectivetransform}{vtk\-Perspective\-Transform}  
\item \hyperlink{vtkcommon_vtkplane}{vtk\-Plane}  
\item \hyperlink{vtkcommon_vtkplanecollection}{vtk\-Plane\-Collection}  
\item \hyperlink{vtkcommon_vtkplanes}{vtk\-Planes}  
\item \hyperlink{vtkcommon_vtkpoints}{vtk\-Points}  
\item \hyperlink{vtkcommon_vtkpoints2d}{vtk\-Points2\-D}  
\item \hyperlink{vtkcommon_vtkpolynomialsolversunivariate}{vtk\-Polynomial\-Solvers\-Univariate}  
\item \hyperlink{vtkcommon_vtkpriorityqueue}{vtk\-Priority\-Queue}  
\item \hyperlink{vtkcommon_vtkprop}{vtk\-Prop}  
\item \hyperlink{vtkcommon_vtkpropcollection}{vtk\-Prop\-Collection}  
\item \hyperlink{vtkcommon_vtkproperty2d}{vtk\-Property2\-D}  
\item \hyperlink{vtkcommon_vtkquadratureschemedefinition}{vtk\-Quadrature\-Scheme\-Definition}  
\item \hyperlink{vtkcommon_vtkquadric}{vtk\-Quadric}  
\item \hyperlink{vtkcommon_vtkrandomsequence}{vtk\-Random\-Sequence}  
\item \hyperlink{vtkcommon_vtkreferencecount}{vtk\-Reference\-Count}  
\item \hyperlink{vtkcommon_vtkrungekutta2}{vtk\-Runge\-Kutta2}  
\item \hyperlink{vtkcommon_vtkrungekutta4}{vtk\-Runge\-Kutta4}  
\item \hyperlink{vtkcommon_vtkrungekutta45}{vtk\-Runge\-Kutta45}  
\item \hyperlink{vtkcommon_vtkscalarstocolors}{vtk\-Scalars\-To\-Colors}  
\item \hyperlink{vtkcommon_vtkserversocket}{vtk\-Server\-Socket}  
\item \hyperlink{vtkcommon_vtkshortarray}{vtk\-Short\-Array}  
\item \hyperlink{vtkcommon_vtksignedchararray}{vtk\-Signed\-Char\-Array}  
\item \hyperlink{vtkcommon_vtksocket}{vtk\-Socket}  
\item \hyperlink{vtkcommon_vtksocketcollection}{vtk\-Socket\-Collection}  
\item \hyperlink{vtkcommon_vtksphericaltransform}{vtk\-Spherical\-Transform}  
\item \hyperlink{vtkcommon_vtkstringarray}{vtk\-String\-Array}  
\item \hyperlink{vtkcommon_vtkstructureddata}{vtk\-Structured\-Data}  
\item \hyperlink{vtkcommon_vtkstructuredvisibilityconstraint}{vtk\-Structured\-Visibility\-Constraint}  
\item \hyperlink{vtkcommon_vtktableextenttranslator}{vtk\-Table\-Extent\-Translator}  
\item \hyperlink{vtkcommon_vtktensor}{vtk\-Tensor}  
\item \hyperlink{vtkcommon_vtkthreadmessager}{vtk\-Thread\-Messager}  
\item \hyperlink{vtkcommon_vtktimepointutility}{vtk\-Time\-Point\-Utility}  
\item \hyperlink{vtkcommon_vtktimerlog}{vtk\-Timer\-Log}  
\item \hyperlink{vtkcommon_vtktransform}{vtk\-Transform}  
\item \hyperlink{vtkcommon_vtktransform2d}{vtk\-Transform2\-D}  
\item \hyperlink{vtkcommon_vtktransformcollection}{vtk\-Transform\-Collection}  
\item \hyperlink{vtkcommon_vtktypefloat32array}{vtk\-Type\-Float32\-Array}  
\item \hyperlink{vtkcommon_vtktypefloat64array}{vtk\-Type\-Float64\-Array}  
\item \hyperlink{vtkcommon_vtktypeint16array}{vtk\-Type\-Int16\-Array}  
\item \hyperlink{vtkcommon_vtktypeint32array}{vtk\-Type\-Int32\-Array}  
\item \hyperlink{vtkcommon_vtktypeint64array}{vtk\-Type\-Int64\-Array}  
\item \hyperlink{vtkcommon_vtktypeint8array}{vtk\-Type\-Int8\-Array}  
\item \hyperlink{vtkcommon_vtktypeuint16array}{vtk\-Type\-U\-Int16\-Array}  
\item \hyperlink{vtkcommon_vtktypeuint32array}{vtk\-Type\-U\-Int32\-Array}  
\item \hyperlink{vtkcommon_vtktypeuint64array}{vtk\-Type\-U\-Int64\-Array}  
\item \hyperlink{vtkcommon_vtktypeuint8array}{vtk\-Type\-U\-Int8\-Array}  
\item \hyperlink{vtkcommon_vtkunicodestringarray}{vtk\-Unicode\-String\-Array}  
\item \hyperlink{vtkcommon_vtkunsignedchararray}{vtk\-Unsigned\-Char\-Array}  
\item \hyperlink{vtkcommon_vtkunsignedintarray}{vtk\-Unsigned\-Int\-Array}  
\item \hyperlink{vtkcommon_vtkunsignedlongarray}{vtk\-Unsigned\-Long\-Array}  
\item \hyperlink{vtkcommon_vtkunsignedlonglongarray}{vtk\-Unsigned\-Long\-Long\-Array}  
\item \hyperlink{vtkcommon_vtkunsignedshortarray}{vtk\-Unsigned\-Short\-Array}  
\item \hyperlink{vtkcommon_vtkvariantarray}{vtk\-Variant\-Array}  
\item \hyperlink{vtkcommon_vtkversion}{vtk\-Version}  
\item \hyperlink{vtkcommon_vtkvoidarray}{vtk\-Void\-Array}  
\item \hyperlink{vtkcommon_vtkwarptransform}{vtk\-Warp\-Transform}  
\item \hyperlink{vtkcommon_vtkwindow}{vtk\-Window}  
\item \hyperlink{vtkcommon_vtkwindowlevellookuptable}{vtk\-Window\-Level\-Lookup\-Table}  
\item \hyperlink{vtkcommon_vtkxmldataelement}{vtk\-X\-M\-L\-Data\-Element}  
\item \hyperlink{vtkcommon_vtkxmlfileoutputwindow}{vtk\-X\-M\-L\-File\-Output\-Window}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkabstractarray}{}\section{vtk\-Abstract\-Array}\label{vtkcommon_vtkabstractarray}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Abstract\-Array is an abstract superclass for data array objects. This class defines an A\-P\-I that all subclasses must support. The data type must be assignable and copy-\/constructible, but no other assumptions about its type are made. Most of the subclasses of this array deal with numeric data either as scalars or tuples of scalars. A program can use the Is\-Numeric() method to check whether an instance of vtk\-Abstract\-Array contains numbers. It is also possible to test for this by attempting to Safe\-Down\-Cast an array to an instance of vtk\-Data\-Array, although this assumes that all numeric arrays will always be descended from vtk\-Data\-Array.

Every array has a character-\/string name. The naming of the array occurs automatically when it is instantiated, but you are free to change this name using the Set\-Name() method. (The array name is used for data manipulation.)

To create an instance of class vtk\-Abstract\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAbstractArray
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Abstract\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Abstract\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Abstract\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Abstract\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Allocate (vtk\-Id\-Type sz, vtk\-Id\-Type ext)} -\/ Allocate memory for this array. Delete old storage only if necessary. Note that ext is no longer used.  
\item {\ttfamily obj.\-Initialize ()} -\/ Release storage and reset array to initial state.  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()} -\/ Return the underlying data type. An integer indicating data type is returned as specified in vtk\-Set\-Get.\-h.  
\item {\ttfamily int = obj.\-Get\-Data\-Type\-Size ()} -\/ Return the size of the underlying data type. For a bit, 0 is returned. For string 0 is returned. Arrays with variable length components return 0.  
\item {\ttfamily int = obj.\-Get\-Element\-Component\-Size ()} -\/ Return the size, in bytes, of the lowest-\/level element of an array. For vtk\-Data\-Array and subclasses this is the size of the data type. For vtk\-String\-Array, this is sizeof(vtk\-Std\-String\-::value\-\_\-type), which winds up being sizeof(char).  
\item {\ttfamily obj.\-Set\-Number\-Of\-Components (int )} -\/ Set/\-Get the dimention (n) of the components. Must be $>$= 1. Make sure that this is set before allocation.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components\-Min\-Value ()} -\/ Set/\-Get the dimention (n) of the components. Must be $>$= 1. Make sure that this is set before allocation.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components\-Max\-Value ()} -\/ Set/\-Get the dimention (n) of the components. Must be $>$= 1. Make sure that this is set before allocation.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components ()} -\/ Set the number of tuples (a component group) in the array. Note that this may allocate space depending on the number of components. Also note that if allocation is performed no copy is performed so existing data will be lost (if data conservation is sought, one may use the Resize method instead).  
\item {\ttfamily obj.\-Set\-Number\-Of\-Tuples (vtk\-Id\-Type number)} -\/ Set the number of tuples (a component group) in the array. Note that this may allocate space depending on the number of components. Also note that if allocation is performed no copy is performed so existing data will be lost (if data conservation is sought, one may use the Resize method instead).  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Tuples ()} -\/ Set the tuple at the ith location using the jth tuple in the source array. This method assumes that the two arrays have the same type and structure. Note that range checking and memory allocation is not performed; use in conjunction with Set\-Number\-Of\-Tuples() to allocate space.  
\item {\ttfamily obj.\-Set\-Tuple (vtk\-Id\-Type i, vtk\-Id\-Type j, vtk\-Abstract\-Array source)} -\/ Set the tuple at the ith location using the jth tuple in the source array. This method assumes that the two arrays have the same type and structure. Note that range checking and memory allocation is not performed; use in conjunction with Set\-Number\-Of\-Tuples() to allocate space.  
\item {\ttfamily obj.\-Insert\-Tuple (vtk\-Id\-Type i, vtk\-Id\-Type j, vtk\-Abstract\-Array source)} -\/ Insert the jth tuple in the source array, at ith location in this array. Note that memory allocation is performed as necessary to hold the data.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Tuple (vtk\-Id\-Type j, vtk\-Abstract\-Array source)} -\/ Insert the jth tuple in the source array, at the end in this array. Note that memory allocation is performed as necessary to hold the data. Returns the location at which the data was inserted.  
\item {\ttfamily obj.\-Get\-Tuples (vtk\-Id\-List pt\-Ids, vtk\-Abstract\-Array output)} -\/ Given a list of point ids, return an array of tuples. You must insure that the output array has been previously allocated with enough space to hold the data.  
\item {\ttfamily obj.\-Get\-Tuples (vtk\-Id\-Type p1, vtk\-Id\-Type p2, vtk\-Abstract\-Array output)} -\/ Get the tuples for the range of points ids specified (i.\-e., p1-\/$>$p2 inclusive). You must insure that the output array has been previously allocated with enough space to hold the data.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Abstract\-Array da)} -\/ Deep copy of data. Implementation left to subclasses, which should support as many type conversions as possible given the data type.

Subclasses should call vtk\-Abstract\-Array\-::\-Deep\-Copy() so that the information object (if one exists) is copied from {\itshape da}.  
\item {\ttfamily obj.\-Interpolate\-Tuple (vtk\-Id\-Type i, vtk\-Id\-List pt\-Indices, vtk\-Abstract\-Array source, double weights)} -\/ Set the ith tuple in this array as the interpolated tuple value, given the pt\-Indices in the source array and associated interpolation weights. This method assumes that the two arrays are of the same type and strcuture.  
\item {\ttfamily obj.\-Interpolate\-Tuple (vtk\-Id\-Type i, vtk\-Id\-Type id1, vtk\-Abstract\-Array source1, vtk\-Id\-Type id2, vtk\-Abstract\-Array source2, double t)}  
\item {\ttfamily obj.\-Squeeze ()} -\/ Resize object to just fit data requirement. Reclaims extra memory.  
\item {\ttfamily int = obj.\-Resize (vtk\-Id\-Type num\-Tuples)} -\/ Resize the array while conserving the data. Returns 1 if resizing succeeded and 0 otherwise.  
\item {\ttfamily obj.\-Reset ()} -\/ Return the size of the data.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Size ()} -\/ What is the maximum id currently in the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Max\-Id ()} -\/ This method lets the user specify data to be held by the array. The array argument is a pointer to the data. size is the size of the array supplied by the user. Set save to 1 to keep the class from deleting the array when it cleans up or reallocates memory. The class uses the actual array provided; it does not copy the data from the supplied array.  
\item {\ttfamily long = obj.\-Get\-Actual\-Memory\-Size ()} -\/ Return the memory in kilobytes consumed by this data array. Used to support streaming and reading/writing data. The value returned is guaranteed to be greater than or equal to the memory required to actually represent the data represented by this object. The information returned is valid only after the pipeline has been updated.  
\item {\ttfamily obj.\-Set\-Name (string )} -\/ Set/get array's name  
\item {\ttfamily string = obj.\-Get\-Name ()} -\/ Set/get array's name  
\item {\ttfamily string = obj.\-Get\-Data\-Type\-As\-String (void )} -\/ Creates an array for data\-Type where data\-Type is one of V\-T\-K\-\_\-\-B\-I\-T, V\-T\-K\-\_\-\-C\-H\-A\-R, V\-T\-K\-\_\-\-U\-N\-S\-I\-G\-N\-E\-D\-\_\-\-C\-H\-A\-R, V\-T\-K\-\_\-\-S\-H\-O\-R\-T, V\-T\-K\-\_\-\-U\-N\-S\-I\-G\-N\-E\-D\-\_\-\-S\-H\-O\-R\-T, V\-T\-K\-\_\-\-I\-N\-T, V\-T\-K\-\_\-\-U\-N\-S\-I\-G\-N\-E\-D\-\_\-\-I\-N\-T, V\-T\-K\-\_\-\-L\-O\-N\-G, V\-T\-K\-\_\-\-U\-N\-S\-I\-G\-N\-E\-D\-\_\-\-L\-O\-N\-G, V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E, V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E, V\-T\-K\-\_\-\-I\-D\-\_\-\-T\-Y\-P\-E, V\-T\-K\-\_\-\-S\-T\-R\-I\-N\-G. Note that the data array returned has be deleted by the user.  
\item {\ttfamily int = obj.\-Is\-Numeric ()} -\/ This method is here to make backward compatibility easier. It must return true if and only if an array contains numeric data.  
\item {\ttfamily vtk\-Array\-Iterator = obj.\-New\-Iterator ()} -\/ Subclasses must override this method and provide the right kind of templated vtk\-Array\-Iterator\-Template.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Data\-Size ()} -\/ Tell the array explicitly that the data has changed. This is only necessary to call when you modify the array contents without using the array's A\-P\-I (i.\-e. you retrieve a pointer to the data and modify the array contents). You need to call this so that the fast lookup will know to rebuild itself. Otherwise, the lookup functions will give incorrect results.  
\item {\ttfamily obj.\-Data\-Changed ()} -\/ Tell the array explicitly that the data has changed. This is only necessary to call when you modify the array contents without using the array's A\-P\-I (i.\-e. you retrieve a pointer to the data and modify the array contents). You need to call this so that the fast lookup will know to rebuild itself. Otherwise, the lookup functions will give incorrect results.  
\item {\ttfamily obj.\-Clear\-Lookup ()} -\/ Delete the associated fast lookup data structure on this array, if it exists. The lookup will be rebuilt on the next call to a lookup function.  
\item {\ttfamily vtk\-Information = obj.\-Get\-Information ()} -\/ Get an information object that can be used to annotate the array. This will always return an instance of vtk\-Information, if one is not currently associated with the array it will be created.  
\item {\ttfamily bool = obj.\-Has\-Information ()}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkabstracttransform}{}\section{vtk\-Abstract\-Transform}\label{vtkcommon_vtkabstracttransform}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Abstract\-Transform is the superclass for all V\-T\-K geometric transformations. The V\-T\-K transform hierarchy is split into two major branches\-: warp transformations and homogeneous (including linear) transformations. The latter can be represented in terms of a 4x4 transformation matrix, the former cannot. 

Transformations can be pipelined through two mechanisms\-: 

1) Get\-Inverse() returns the pipelined inverse of a transformation i.\-e. if you modify the original transform, any transform previously returned by the Get\-Inverse() method will automatically update itself according to the change. 

2) You can do pipelined concatenation of transformations through the vtk\-General\-Transform class, the vtk\-Perspective\-Transform class, or the vtk\-Transform class.

To create an instance of class vtk\-Abstract\-Transform, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAbstractTransform
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Abstract\-Transform has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Abstract\-Transform class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Transform\-Point (float in\mbox{[}3\mbox{]}, float out\mbox{[}3\mbox{]})} -\/ Apply the transformation to a coordinate. You can use the same array to store both the input and output point.  
\item {\ttfamily obj.\-Transform\-Point (double in\mbox{[}3\mbox{]}, double out\mbox{[}3\mbox{]})} -\/ Apply the transformation to a double-\/precision coordinate. You can use the same array to store both the input and output point.  
\item {\ttfamily double = obj.\-Transform\-Point (double x, double y, double z)} -\/ Apply the transformation to a double-\/precision coordinate. Use this if you are programming in Python, tcl or Java.  
\item {\ttfamily double = obj.\-Transform\-Point (double point\mbox{[}3\mbox{]})} -\/ Apply the transformation to a double-\/precision coordinate. Use this if you are programming in Python, tcl or Java.  
\item {\ttfamily float = obj.\-Transform\-Float\-Point (float x, float y, float z)} -\/ Apply the transformation to an (x,y,z) coordinate. Use this if you are programming in Python, tcl or Java.  
\item {\ttfamily float = obj.\-Transform\-Float\-Point (float point\mbox{[}3\mbox{]})} -\/ Apply the transformation to an (x,y,z) coordinate. Use this if you are programming in Python, tcl or Java.  
\item {\ttfamily double = obj.\-Transform\-Double\-Point (double x, double y, double z)} -\/ Apply the transformation to a double-\/precision (x,y,z) coordinate. Use this if you are programming in Python, tcl or Java.  
\item {\ttfamily double = obj.\-Transform\-Double\-Point (double point\mbox{[}3\mbox{]})} -\/ Apply the transformation to a double-\/precision (x,y,z) coordinate. Use this if you are programming in Python, tcl or Java.  
\item {\ttfamily obj.\-Transform\-Normal\-At\-Point (float point\mbox{[}3\mbox{]}, float in\mbox{[}3\mbox{]}, float out\mbox{[}3\mbox{]})} -\/ Apply the transformation to a normal at the specified vertex. If the transformation is a vtk\-Linear\-Transform, you can use Transform\-Normal() instead.  
\item {\ttfamily obj.\-Transform\-Normal\-At\-Point (double point\mbox{[}3\mbox{]}, double in\mbox{[}3\mbox{]}, double out\mbox{[}3\mbox{]})} -\/ Apply the transformation to a normal at the specified vertex. If the transformation is a vtk\-Linear\-Transform, you can use Transform\-Normal() instead.  
\item {\ttfamily double = obj.\-Transform\-Normal\-At\-Point (double point\mbox{[}3\mbox{]}, double normal\mbox{[}3\mbox{]})}  
\item {\ttfamily double = obj.\-Transform\-Double\-Normal\-At\-Point (double point\mbox{[}3\mbox{]}, double normal\mbox{[}3\mbox{]})} -\/ Apply the transformation to a double-\/precision normal at the specified vertex. If the transformation is a vtk\-Linear\-Transform, you can use Transform\-Double\-Normal() instead.  
\item {\ttfamily float = obj.\-Transform\-Float\-Normal\-At\-Point (float point\mbox{[}3\mbox{]}, float normal\mbox{[}3\mbox{]})} -\/ Apply the transformation to a single-\/precision normal at the specified vertex. If the transformation is a vtk\-Linear\-Transform, you can use Transform\-Float\-Normal() instead.  
\item {\ttfamily obj.\-Transform\-Vector\-At\-Point (float point\mbox{[}3\mbox{]}, float in\mbox{[}3\mbox{]}, float out\mbox{[}3\mbox{]})} -\/ Apply the transformation to a vector at the specified vertex. If the transformation is a vtk\-Linear\-Transform, you can use Transform\-Vector() instead.  
\item {\ttfamily obj.\-Transform\-Vector\-At\-Point (double point\mbox{[}3\mbox{]}, double in\mbox{[}3\mbox{]}, double out\mbox{[}3\mbox{]})} -\/ Apply the transformation to a vector at the specified vertex. If the transformation is a vtk\-Linear\-Transform, you can use Transform\-Vector() instead.  
\item {\ttfamily double = obj.\-Transform\-Vector\-At\-Point (double point\mbox{[}3\mbox{]}, double vector\mbox{[}3\mbox{]})}  
\item {\ttfamily double = obj.\-Transform\-Double\-Vector\-At\-Point (double point\mbox{[}3\mbox{]}, double vector\mbox{[}3\mbox{]})} -\/ Apply the transformation to a double-\/precision vector at the specified vertex. If the transformation is a vtk\-Linear\-Transform, you can use Transform\-Double\-Vector() instead.  
\item {\ttfamily float = obj.\-Transform\-Float\-Vector\-At\-Point (float point\mbox{[}3\mbox{]}, float vector\mbox{[}3\mbox{]})} -\/ Apply the transformation to a single-\/precision vector at the specified vertex. If the transformation is a vtk\-Linear\-Transform, you can use Transform\-Float\-Vector() instead.  
\item {\ttfamily obj.\-Transform\-Points (vtk\-Points in\-Pts, vtk\-Points out\-Pts)} -\/ Apply the transformation to a series of points, and append the results to out\-Pts.  
\item {\ttfamily obj.\-Transform\-Points\-Normals\-Vectors (vtk\-Points in\-Pts, vtk\-Points out\-Pts, vtk\-Data\-Array in\-Nms, vtk\-Data\-Array out\-Nms, vtk\-Data\-Array in\-Vrs, vtk\-Data\-Array out\-Vrs)} -\/ Apply the transformation to a combination of points, normals and vectors.  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Get\-Inverse ()} -\/ Get the inverse of this transform. If you modify this transform, the returned inverse transform will automatically update. If you want the inverse of a vtk\-Transform, you might want to use Get\-Linear\-Inverse() instead which will type cast the result from vtk\-Abstract\-Transform to vtk\-Linear\-Transform.  
\item {\ttfamily obj.\-Set\-Inverse (vtk\-Abstract\-Transform transform)} -\/ Set a transformation that this transform will be the inverse of. This transform will automatically update to agree with the inverse transform that you set.  
\item {\ttfamily obj.\-Inverse ()} -\/ Invert the transformation.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Abstract\-Transform )} -\/ Copy this transform from another of the same type.  
\item {\ttfamily obj.\-Update ()} -\/ Update the transform to account for any changes which have been made. You do not have to call this method yourself, it is called automatically whenever the transform needs an update.  
\item {\ttfamily obj.\-Internal\-Transform\-Point (float in\mbox{[}3\mbox{]}, float out\mbox{[}3\mbox{]})} -\/ This will calculate the transformation without calling Update. Meant for use only within other V\-T\-K classes.  
\item {\ttfamily obj.\-Internal\-Transform\-Point (double in\mbox{[}3\mbox{]}, double out\mbox{[}3\mbox{]})} -\/ This will calculate the transformation without calling Update. Meant for use only within other V\-T\-K classes.  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Make\-Transform ()} -\/ Make another transform of the same type.  
\item {\ttfamily int = obj.\-Circuit\-Check (vtk\-Abstract\-Transform transform)} -\/ Check for self-\/reference. Will return true if concatenating with the specified transform, setting it to be our inverse, or setting it to be our input will create a circular reference. Circuit\-Check is automatically called by Set\-Input(), Set\-Inverse(), and Concatenate(vtk\-X\-Transform $\ast$). Avoid using this function, it is experimental.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Override Get\-M\-Time necessary because of inverse transforms.  
\item {\ttfamily obj.\-Un\-Register (vtk\-Object\-Base O)} -\/ Needs a special Un\-Register() implementation to avoid circular references.  
\item {\ttfamily obj.\-Identity ()} -\/  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkamoebaminimizer}{}\section{vtk\-Amoeba\-Minimizer}\label{vtkcommon_vtkamoebaminimizer}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Amoeba\-Minimizer will modify a set of parameters in order to find the minimum of a specified function. The method used is commonly known as the amoeba method, it constructs an n-\/dimensional simplex in parameter space (i.\-e. a tetrahedron if the number or parameters is 3) and moves the vertices around parameter space until a local minimum is found. The amoeba method is robust, reasonably efficient, but is not guaranteed to find the global minimum if several local minima exist.

To create an instance of class vtk\-Amoeba\-Minimizer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAmoebaMinimizer
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Amoeba\-Minimizer has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Amoeba\-Minimizer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Amoeba\-Minimizer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Amoeba\-Minimizer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Parameter\-Value (string name, double value)} -\/ Set the initial value for the specified parameter. Calling this function for any parameter will reset the Iterations and the Function\-Evaluations counts to zero. You must also use Set\-Parameter\-Scale() to specify the step size by which the parameter will be modified during the minimization. It is preferable to specify parameters by name, rather than by number.  
\item {\ttfamily obj.\-Set\-Parameter\-Value (int i, double value)} -\/ Set the initial value for the specified parameter. Calling this function for any parameter will reset the Iterations and the Function\-Evaluations counts to zero. You must also use Set\-Parameter\-Scale() to specify the step size by which the parameter will be modified during the minimization. It is preferable to specify parameters by name, rather than by number.  
\item {\ttfamily obj.\-Set\-Parameter\-Scale (string name, double scale)} -\/ Set the scale to use when modifying a parameter, i.\-e. the initial amount by which the parameter will be modified during the search for the minimum. It is preferable to identify scalars by name rather than by number.  
\item {\ttfamily double = obj.\-Get\-Parameter\-Scale (string name)} -\/ Set the scale to use when modifying a parameter, i.\-e. the initial amount by which the parameter will be modified during the search for the minimum. It is preferable to identify scalars by name rather than by number.  
\item {\ttfamily obj.\-Set\-Parameter\-Scale (int i, double scale)} -\/ Set the scale to use when modifying a parameter, i.\-e. the initial amount by which the parameter will be modified during the search for the minimum. It is preferable to identify scalars by name rather than by number.  
\item {\ttfamily double = obj.\-Get\-Parameter\-Scale (int i)} -\/ Set the scale to use when modifying a parameter, i.\-e. the initial amount by which the parameter will be modified during the search for the minimum. It is preferable to identify scalars by name rather than by number.  
\item {\ttfamily double = obj.\-Get\-Parameter\-Value (string name)} -\/ Get the value of a parameter at the current stage of the minimization. Call this method within the function that you are minimizing in order to get the current parameter values. It is preferable to specify parameters by name rather than by index.  
\item {\ttfamily double = obj.\-Get\-Parameter\-Value (int i)} -\/ Get the value of a parameter at the current stage of the minimization. Call this method within the function that you are minimizing in order to get the current parameter values. It is preferable to specify parameters by name rather than by index.  
\item {\ttfamily string = obj.\-Get\-Parameter\-Name (int i)} -\/ For completeness, an unchecked method to get the name for particular parameter (the result will be N\-U\-L\-L if no name was set).  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Parameters ()} -\/ Get the number of parameters that have been set.  
\item {\ttfamily obj.\-Initialize ()} -\/ Initialize the minimizer. This will reset the number of parameters to zero so that the minimizer can be reused.  
\item {\ttfamily obj.\-Minimize ()} -\/ Iterate until the minimum is found to within the specified tolerance, or until the Max\-Iterations has been reached.  
\item {\ttfamily int = obj.\-Iterate ()} -\/ Perform one iteration of minimization. Returns zero if the tolerance stopping criterion has been met.  
\item {\ttfamily obj.\-Set\-Function\-Value (double )} -\/ Get the function value resulting from the minimization.  
\item {\ttfamily double = obj.\-Get\-Function\-Value ()} -\/ Get the function value resulting from the minimization.  
\item {\ttfamily obj.\-Set\-Tolerance (double )} -\/ Specify the fractional tolerance to aim for during the minimization.  
\item {\ttfamily double = obj.\-Get\-Tolerance ()} -\/ Specify the fractional tolerance to aim for during the minimization.  
\item {\ttfamily obj.\-Set\-Max\-Iterations (int )} -\/ Specify the maximum number of iterations to try before giving up.  
\item {\ttfamily int = obj.\-Get\-Max\-Iterations ()} -\/ Specify the maximum number of iterations to try before giving up.  
\item {\ttfamily int = obj.\-Get\-Iterations ()} -\/ Return the number of interations that have been performed. This is not necessarily the same as the number of function evaluations.  
\item {\ttfamily int = obj.\-Get\-Function\-Evaluations ()} -\/ Return the number of times that the function has been evaluated.  
\item {\ttfamily obj.\-Evaluate\-Function ()} -\/ Evaluate the function. This is usually called internally by the minimization code, but it is provided here as a public method.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkanimationcue}{}\section{vtk\-Animation\-Cue}\label{vtkcommon_vtkanimationcue}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Animation\-Cue and vtk\-Animation\-Scene provide the framework to support animations in V\-T\-K. vtk\-Animation\-Cue represents an entity that changes/ animates with time, while vtk\-Animation\-Scene represents scene or setup for the animation, which consists on individual cues or other scenes.

A cue has three states\-: U\-N\-I\-N\-I\-T\-I\-A\-L\-I\-Z\-E\-D, A\-C\-T\-I\-V\-E and I\-N\-A\-C\-T\-I\-V\-E. U\-N\-I\-N\-I\-T\-I\-A\-L\-I\-Z\-E\-D represents an point in time before the start time of the cue. The cue is in A\-C\-T\-I\-V\-E state at a point in time between start time and end time for the cue. While, beyond the end time, it is in I\-N\-A\-C\-T\-I\-V\-E state. When the cue enters the A\-C\-T\-I\-V\-E state, Start\-Animation\-Cue\-Event is fired. This event may be handled to initialize the entity to be animated. When the cue leaves the A\-C\-T\-I\-V\-E state, End\-Animation\-Cue\-Event is fired, which can be handled to cleanup after having run the animation. For every request to render during the A\-C\-T\-I\-V\-E state, Animation\-Cue\-Tick\-Event is fired, which must be handled to perform the actual animation.

To create an instance of class vtk\-Animation\-Cue, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAnimationCue
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Animation\-Cue has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Animation\-Cue class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Animation\-Cue = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Animation\-Cue = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Time\-Mode (int mode)} -\/ Get/\-Set the time mode. In Normalized mode, the start and end times of the cue are normalized \mbox{[}0,1\mbox{]} with respect to the start and end times of the container scene. In Relative mode the start and end time of the cue are specified in offset seconds relative to the start time of the container scene.  
\item {\ttfamily int = obj.\-Get\-Time\-Mode ()} -\/ Get/\-Set the time mode. In Normalized mode, the start and end times of the cue are normalized \mbox{[}0,1\mbox{]} with respect to the start and end times of the container scene. In Relative mode the start and end time of the cue are specified in offset seconds relative to the start time of the container scene.  
\item {\ttfamily obj.\-Set\-Time\-Mode\-To\-Relative ()} -\/ Get/\-Set the time mode. In Normalized mode, the start and end times of the cue are normalized \mbox{[}0,1\mbox{]} with respect to the start and end times of the container scene. In Relative mode the start and end time of the cue are specified in offset seconds relative to the start time of the container scene.  
\item {\ttfamily obj.\-Set\-Time\-Mode\-To\-Normalized ()} -\/ Get/\-Set the Start time for this cue. When the current time is $>$= Start\-Time, the Cue is in A\-C\-T\-I\-V\-E state. if Current time i $<$ Start\-Time, the Cue is in U\-N\-I\-N\-I\-T\-I\-A\-L\-I\-Z\-E\-D state. Whenever the cue enters the A\-C\-T\-I\-V\-E state from an I\-N\-A\-C\-T\-I\-V\-E state, it triggers the Start\-Event. The Start time is in seconds relative to the start of the container Scene (when in Relative time mode) or is normalized over the span of the container Scene (when in Normalized time mode).  
\item {\ttfamily obj.\-Set\-Start\-Time (double )} -\/ Get/\-Set the Start time for this cue. When the current time is $>$= Start\-Time, the Cue is in A\-C\-T\-I\-V\-E state. if Current time i $<$ Start\-Time, the Cue is in U\-N\-I\-N\-I\-T\-I\-A\-L\-I\-Z\-E\-D state. Whenever the cue enters the A\-C\-T\-I\-V\-E state from an I\-N\-A\-C\-T\-I\-V\-E state, it triggers the Start\-Event. The Start time is in seconds relative to the start of the container Scene (when in Relative time mode) or is normalized over the span of the container Scene (when in Normalized time mode).  
\item {\ttfamily double = obj.\-Get\-Start\-Time ()} -\/ Get/\-Set the Start time for this cue. When the current time is $>$= Start\-Time, the Cue is in A\-C\-T\-I\-V\-E state. if Current time i $<$ Start\-Time, the Cue is in U\-N\-I\-N\-I\-T\-I\-A\-L\-I\-Z\-E\-D state. Whenever the cue enters the A\-C\-T\-I\-V\-E state from an I\-N\-A\-C\-T\-I\-V\-E state, it triggers the Start\-Event. The Start time is in seconds relative to the start of the container Scene (when in Relative time mode) or is normalized over the span of the container Scene (when in Normalized time mode).  
\item {\ttfamily obj.\-Set\-End\-Time (double )} -\/ Get/\-Set the End time for this cue. When the current time is $>$ End\-Time, the Cue is in I\-N\-A\-C\-T\-I\-V\-E state. Whenever the cue leaves an A\-C\-T\-I\-V\-E state to enter I\-N\-A\-C\-T\-I\-V\-E state, the End\-Event is triggered. The End time is in seconds relative to the start of the container Scene (when in Relative time mode) or is normalized over the span of the container Scene (when in Normalized time mode).  
\item {\ttfamily double = obj.\-Get\-End\-Time ()} -\/ Get/\-Set the End time for this cue. When the current time is $>$ End\-Time, the Cue is in I\-N\-A\-C\-T\-I\-V\-E state. Whenever the cue leaves an A\-C\-T\-I\-V\-E state to enter I\-N\-A\-C\-T\-I\-V\-E state, the End\-Event is triggered. The End time is in seconds relative to the start of the container Scene (when in Relative time mode) or is normalized over the span of the container Scene (when in Normalized time mode).  
\item {\ttfamily obj.\-Tick (double currenttime, double deltatime, double clocktime)} -\/ Indicates a tick or point in time in the animation. Triggers a Tick event if currenttime $>$= Start\-Time and currenttime $<$= End\-Time. Whenever the state of the cue changes, either Start\-Event or End\-Event is triggerred depending upon whether the cue entered Active state or quit active state respectively. The current time is relative to the start of the container Scene (when in Relative time mode) or is normalized over the span of the container Scene (when in Normalized time mode). deltatime is the time since last call to Tick. deltatime also can be in seconds relative to the start of the container Scene or normalized depending upon the cue's Time mode. clocktime is the time from the scene i.\-e. it does not depend on the time mode for the cue. For the first call to Tick after a call to Initialize(), the deltatime is 0;  
\item {\ttfamily obj.\-Initialize ()} -\/ Called when the playing of the scene begins. This will set the Cue to U\-N\-I\-N\-I\-T\-I\-A\-L\-I\-Z\-E\-D state.  
\item {\ttfamily obj.\-Finalize ()} -\/ Called when the scene reaches the end. If the cue state is A\-C\-T\-I\-V\-E when this method is called, this will trigger a End\-Animation\-Cue\-Event.  
\item {\ttfamily double = obj.\-Get\-Animation\-Time ()} -\/ This is valid only in a Animation\-Cue\-Tick\-Event handler. Before firing the event the animation cue sets the Animation\-Time to the time of the tick.  
\item {\ttfamily double = obj.\-Get\-Delta\-Time ()} -\/ This is valid only in a Animation\-Cue\-Tick\-Event handler. Before firing the event the animation cue sets the Delta\-Time to the difference in time between the current tick and the last tick.  
\item {\ttfamily double = obj.\-Get\-Clock\-Time ()} -\/ This is valid only in a Animation\-Cue\-Tick\-Event handler. Before firing the event the animation cue sets the Clock\-Time to the time of the tick. Clock\-Time is directly the time from the animation scene neither normalized nor offsetted to the start of the scene.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkanimationscene}{}\section{vtk\-Animation\-Scene}\label{vtkcommon_vtkanimationscene}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Animation\-Cue and vtk\-Animation\-Scene provide the framework to support animations in V\-T\-K. vtk\-Animation\-Cue represents an entity that changes/ animates with time, while vtk\-Animation\-Scene represents scene or setup for the animation, which consists of individual cues or other scenes.

A scene can be played in real time mode, or as a seqence of frames 1/frame rate apart in time.

To create an instance of class vtk\-Animation\-Scene, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAnimationScene
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Animation\-Scene has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Animation\-Scene class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Animation\-Scene = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Animation\-Scene = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Play\-Mode (int )} -\/ Get/\-Set the Play\-Mode for running/playing the animation scene. In the Sequence mode, all the frames are generated one after the other. The time reported to each Tick of the constituent cues (during Play) is incremented by 1/frame rate, irrespective of the current time. In the Real\-Time mode, time indicates the instance in time.  
\item {\ttfamily obj.\-Set\-Mode\-To\-Sequence ()} -\/ Get/\-Set the Play\-Mode for running/playing the animation scene. In the Sequence mode, all the frames are generated one after the other. The time reported to each Tick of the constituent cues (during Play) is incremented by 1/frame rate, irrespective of the current time. In the Real\-Time mode, time indicates the instance in time.  
\item {\ttfamily obj.\-Set\-Mode\-To\-Real\-Time ()} -\/ Get/\-Set the Play\-Mode for running/playing the animation scene. In the Sequence mode, all the frames are generated one after the other. The time reported to each Tick of the constituent cues (during Play) is incremented by 1/frame rate, irrespective of the current time. In the Real\-Time mode, time indicates the instance in time.  
\item {\ttfamily int = obj.\-Get\-Play\-Mode ()} -\/ Get/\-Set the Play\-Mode for running/playing the animation scene. In the Sequence mode, all the frames are generated one after the other. The time reported to each Tick of the constituent cues (during Play) is incremented by 1/frame rate, irrespective of the current time. In the Real\-Time mode, time indicates the instance in time.  
\item {\ttfamily obj.\-Set\-Frame\-Rate (double )} -\/ Get/\-Set the frame rate (in frames per second). This parameter affects only in the Sequence mode. The time interval indicated to each cue on every tick is progressed by 1/frame-\/rate seconds.  
\item {\ttfamily double = obj.\-Get\-Frame\-Rate ()} -\/ Get/\-Set the frame rate (in frames per second). This parameter affects only in the Sequence mode. The time interval indicated to each cue on every tick is progressed by 1/frame-\/rate seconds.  
\item {\ttfamily obj.\-Add\-Cue (vtk\-Animation\-Cue cue)} -\/ Add/\-Remove an Animation\-Cue to/from the Scene. It's an error to add a cue twice to the Scene.  
\item {\ttfamily obj.\-Remove\-Cue (vtk\-Animation\-Cue cue)} -\/ Add/\-Remove an Animation\-Cue to/from the Scene. It's an error to add a cue twice to the Scene.  
\item {\ttfamily obj.\-Remove\-All\-Cues ()} -\/ Add/\-Remove an Animation\-Cue to/from the Scene. It's an error to add a cue twice to the Scene.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Cues ()} -\/ Add/\-Remove an Animation\-Cue to/from the Scene. It's an error to add a cue twice to the Scene.  
\item {\ttfamily obj.\-Play ()} -\/ Starts playing the animation scene. Fires a vtk\-Command\-::\-Start\-Event before play beings and vtk\-Command\-::\-End\-Event after play ends.  
\item {\ttfamily obj.\-Stop ()} -\/ Stops the animation scene that is running.  
\item {\ttfamily obj.\-Set\-Loop (int )} -\/ Enable/\-Disable animation loop.  
\item {\ttfamily int = obj.\-Get\-Loop ()} -\/ Enable/\-Disable animation loop.  
\item {\ttfamily obj.\-Set\-Animation\-Time (double time)} -\/ Makes the state of the scene same as the given time.  
\item {\ttfamily double = obj.\-Get\-Animation\-Time ()} -\/ Makes the state of the scene same as the given time.  
\item {\ttfamily obj.\-Set\-Time\-Mode (int mode)} -\/ Overridden to allow change to Normalized mode only if none of the constituent cues is in Relative time mode.  
\item {\ttfamily int = obj.\-Is\-In\-Play ()}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkarray}{}\section{vtk\-Array}\label{vtkcommon_vtkarray}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Array is the root of a hierarchy of arrays that can be used to store data with any number of dimensions. It provides an abstract interface for retrieving and setting array attributes that are independent of the type of values stored in the array -\/ such as the number of dimensions, extents along each dimension, and number of values stored in the array.

To get and set array values, the vtk\-Typed\-Array template class derives from vtk\-Array and provides type-\/specific methods for retrieval and update.

Two concrete derivatives of vtk\-Typed\-Array are provided at the moment\-: vtk\-Dense\-Array and vtk\-Sparse\-Array, which provide dense and sparse storage for arbitrary-\/dimension data, respectively. Toolkit users can create their own concrete derivatives that implement alternative storage strategies, such as compressed-\/sparse-\/row, etc. You could also create an array that provided read-\/only access to 'virtual' data, such as an array that returned a Fibonacci sequence, etc.

To create an instance of class vtk\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkArray
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily bool = obj.\-Is\-Dense ()} -\/ Returns true iff the underlying array storage is \char`\"{}dense\char`\"{}, i.\-e. that Get\-Size() and Get\-Non\-Null\-Size() will always return the same value. If not, the array is \char`\"{}sparse\char`\"{}.  
\item {\ttfamily obj.\-Resize (vtk\-Id\-Type i)} -\/ Resizes the array to the given extents (number of dimensions and size of each dimension). Note that concrete implementations of vtk\-Array may place constraints on the the extents that they will store, so you cannot assume that Get\-Extents() will always return the same value passed to Resize().

The contents of the array are undefined after calling Resize() -\/ you should initialize its contents accordingly. In particular, dimension-\/labels will be undefined, dense array values will be undefined, and sparse arrays will be empty.  
\item {\ttfamily obj.\-Resize (vtk\-Id\-Type i, vtk\-Id\-Type j)} -\/ Resizes the array to the given extents (number of dimensions and size of each dimension). Note that concrete implementations of vtk\-Array may place constraints on the the extents that they will store, so you cannot assume that Get\-Extents() will always return the same value passed to Resize().

The contents of the array are undefined after calling Resize() -\/ you should initialize its contents accordingly. In particular, dimension-\/labels will be undefined, dense array values will be undefined, and sparse arrays will be empty.  
\item {\ttfamily obj.\-Resize (vtk\-Id\-Type i, vtk\-Id\-Type j, vtk\-Id\-Type k)} -\/ Resizes the array to the given extents (number of dimensions and size of each dimension). Note that concrete implementations of vtk\-Array may place constraints on the the extents that they will store, so you cannot assume that Get\-Extents() will always return the same value passed to Resize().

The contents of the array are undefined after calling Resize() -\/ you should initialize its contents accordingly. In particular, dimension-\/labels will be undefined, dense array values will be undefined, and sparse arrays will be empty.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Dimensions ()} -\/ Returns the number of dimensions stored in the array. Note that this is the same as calling Get\-Extents().Get\-Dimensions().  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Size ()} -\/ Returns the number of values stored in the array. Note that this is the same as calling Get\-Extents().Get\-Size(), and represents the maximum number of values that could ever be stored using the current extents. This is equal to the number of values stored in a dense array, but may be larger than the number of values stored in a sparse array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Non\-Null\-Size ()} -\/ Returns the number of non-\/null values stored in the array. Note that this value will equal Get\-Size() for dense arrays, and will be less-\/than-\/or-\/equal to Get\-Size() for sparse arrays.  
\item {\ttfamily obj.\-Set\-Name (vtk\-Std\-String \&name)} -\/ Sets the array name.  
\item {\ttfamily vtk\-Std\-String = obj.\-Get\-Name ()} -\/ Returns the array name.  
\item {\ttfamily obj.\-Set\-Dimension\-Label (vtk\-Id\-Type i, vtk\-Std\-String \&label)} -\/ Sets the label for the i-\/th array dimension.  
\item {\ttfamily vtk\-Std\-String = obj.\-Get\-Dimension\-Label (vtk\-Id\-Type i)} -\/ Returns the label for the i-\/th array dimension.  
\item {\ttfamily vtk\-Array = obj.\-Deep\-Copy ()} -\/ Returns a new array that is a deep copy of this array.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkarrayiterator}{}\section{vtk\-Array\-Iterator}\label{vtkcommon_vtkarrayiterator}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Array\-Iterator is used to iterate over elements in any vtk\-Abstract\-Array subclass. The vtk\-Array\-Iterator\-Template\-Macro is used to centralize the set of types supported by Execute methods. It also avoids duplication of long switch statement case lists. Note that in this macro V\-T\-K\-\_\-\-T\-T is defined to be the type of the iterator for the given type of array. One must include the vtk\-Array\-Iterator\-Includes.\-h header file to provide for extending of this macro by addition of new iterators.

Example usage\-: \begin{DoxyVerb} vtkArrayIter* iter = array->NewIterator();
 switch(array->GetDataType())
   {
   vtkArrayIteratorTemplateMacro(myFunc(static_cast<VTK_TT*>(iter), arg2));
   }
 iter->Delete();
\end{DoxyVerb}


To create an instance of class vtk\-Array\-Iterator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkArrayIterator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Array\-Iterator has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Array\-Iterator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Array\-Iterator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Array\-Iterator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Initialize (vtk\-Abstract\-Array array)} -\/ Set the array this iterator will iterate over. After Initialize() has been called, the iterator is valid so long as the Array has not been modified (except using the iterator itself). If the array is modified, the iterator must be re-\/intialized.  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkassemblynode}{}\section{vtk\-Assembly\-Node}\label{vtkcommon_vtkassemblynode}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Assembly\-Node represents a node in an assembly. It is used by vtk\-Assembly\-Path to create hierarchical assemblies of props. The props can be either 2\-D or 3\-D.

An assembly node refers to a vtk\-Prop, and possibly a vtk\-Matrix4x4. Nodes are used by vtk\-Assembly\-Path to build fully evaluated path (matrices are concatenated through the path) that is used by picking and other operations involving assemblies.

To create an instance of class vtk\-Assembly\-Node, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAssemblyNode
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Assembly\-Node has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Assembly\-Node class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Assembly\-Node = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Assembly\-Node = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-View\-Prop (vtk\-Prop prop)} -\/ Set/\-Get the prop that this assembly node refers to.  
\item {\ttfamily vtk\-Prop = obj.\-Get\-View\-Prop ()} -\/ Set/\-Get the prop that this assembly node refers to.  
\item {\ttfamily obj.\-Set\-Matrix (vtk\-Matrix4x4 matrix)} -\/ Specify a transformation matrix associated with the prop. Note\-: if the prop is not a type of vtk\-Prop3\-D, then the transformation matrix is ignored (and expected to be N\-U\-L\-L). Also, internal to this object the matrix is copied because the matrix is used for computation by vtk\-Assembly\-Path.  
\item {\ttfamily vtk\-Matrix4x4 = obj.\-Get\-Matrix ()} -\/ Specify a transformation matrix associated with the prop. Note\-: if the prop is not a type of vtk\-Prop3\-D, then the transformation matrix is ignored (and expected to be N\-U\-L\-L). Also, internal to this object the matrix is copied because the matrix is used for computation by vtk\-Assembly\-Path.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Override the standard Get\-M\-Time() to check for the modified times of the prop and matrix.  
\item {\ttfamily obj.\-Set\-Prop (vtk\-Prop prop)} -\/  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkassemblypath}{}\section{vtk\-Assembly\-Path}\label{vtkcommon_vtkassemblypath}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Assembly\-Path represents an ordered list of assembly nodes that represent a fully evaluated assembly path. This class is used primarily for picking. Note that the use of this class is to add one or more assembly nodes to form the path. (An assembly node consists of an instance of vtk\-Prop and vtk\-Matrix4x4, the matrix may be N\-U\-L\-L.) As each node is added, the matrices are concatenated to create a final, evaluated matrix.

To create an instance of class vtk\-Assembly\-Path, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAssemblyPath
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Assembly\-Path has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Assembly\-Path class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Assembly\-Path = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Assembly\-Path = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Node (vtk\-Prop p, vtk\-Matrix4x4 m)} -\/ Convenience method adds a prop and matrix together, creating an assembly node transparently. The matrix pointer m may be N\-U\-L\-L. Note\-: that matrix is the one, if any, associated with the prop.  
\item {\ttfamily vtk\-Assembly\-Node = obj.\-Get\-Next\-Node ()} -\/ Get the next assembly node in the list. The node returned contains a pointer to a prop and a 4x4 matrix. The matrix is evaluated based on the preceding assembly hierarchy (i.\-e., the matrix is not necessarily as the same as the one that was added with Add\-Node() because of the concatenation of matrices in the assembly hierarchy).  
\item {\ttfamily vtk\-Assembly\-Node = obj.\-Get\-First\-Node ()} -\/ Get the first assembly node in the list. See the comments for Get\-Next\-Node() regarding the contents of the returned node. (Note\-: This node corresponds to the vtk\-Prop associated with the vtk\-Renderer.  
\item {\ttfamily vtk\-Assembly\-Node = obj.\-Get\-Last\-Node ()} -\/ Get the last assembly node in the list. See the comments for Get\-Next\-Node() regarding the contents of the returned node.  
\item {\ttfamily obj.\-Delete\-Last\-Node ()} -\/ Delete the last assembly node in the list. This is like a stack pop.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Assembly\-Path path)} -\/ Perform a shallow copy (reference counted) on the incoming path.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Override the standard Get\-M\-Time() to check for the modified times of the nodes in this path.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkassemblypaths}{}\section{vtk\-Assembly\-Paths}\label{vtkcommon_vtkassemblypaths}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Assembly\-Paths represents an assembly hierarchy as a list of vtk\-Assembly\-Path. Each path represents the complete path from the top level assembly (if any) down to the leaf prop.

To create an instance of class vtk\-Assembly\-Paths, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAssemblyPaths
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Assembly\-Paths has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Assembly\-Paths class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Assembly\-Paths = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Assembly\-Paths = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Item (vtk\-Assembly\-Path p)} -\/ Add a path to the list.  
\item {\ttfamily obj.\-Remove\-Item (vtk\-Assembly\-Path p)} -\/ Remove a path from the list.  
\item {\ttfamily int = obj.\-Is\-Item\-Present (vtk\-Assembly\-Path p)} -\/ Determine whether a particular path is present. Returns its position in the list.  
\item {\ttfamily vtk\-Assembly\-Path = obj.\-Get\-Next\-Item ()} -\/ Get the next path in the list.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Override the standard Get\-M\-Time() to check for the modified times of the paths.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkbitarray}{}\section{vtk\-Bit\-Array}\label{vtkcommon_vtkbitarray}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Bit\-Array is an array of bits (0/1 data value). The array is packed so that each byte stores eight bits. vtk\-Bit\-Array provides methods for insertion and retrieval of bits, and will automatically resize itself to hold new data.

To create an instance of class vtk\-Bit\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBitArray
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Bit\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Bit\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Bit\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Bit\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Allocate (vtk\-Id\-Type sz, vtk\-Id\-Type ext)} -\/ Allocate memory for this array. Delete old storage only if necessary. Note that ext is no longer used.  
\item {\ttfamily obj.\-Initialize ()} -\/ Release storage and reset array to initial state.  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()}  
\item {\ttfamily int = obj.\-Get\-Data\-Type\-Size ()} -\/ Set the number of n-\/tuples in the array.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Tuples (vtk\-Id\-Type number)} -\/ Set the number of n-\/tuples in the array.  
\item {\ttfamily obj.\-Set\-Tuple (vtk\-Id\-Type i, vtk\-Id\-Type j, vtk\-Abstract\-Array source)} -\/ Set the tuple at the ith location using the jth tuple in the source array. This method assumes that the two arrays have the same type and structure. Note that range checking and memory allocation is not performed; use in conjunction with Set\-Number\-Of\-Tuples() to allocate space.  
\item {\ttfamily obj.\-Insert\-Tuple (vtk\-Id\-Type i, vtk\-Id\-Type j, vtk\-Abstract\-Array source)} -\/ Insert the jth tuple in the source array, at ith location in this array. Note that memory allocation is performed as necessary to hold the data.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Tuple (vtk\-Id\-Type j, vtk\-Abstract\-Array source)} -\/ Insert the jth tuple in the source array, at the end in this array. Note that memory allocation is performed as necessary to hold the data. Returns the location at which the data was inserted.  
\item {\ttfamily obj.\-Get\-Tuple (vtk\-Id\-Type i, double tuple)} -\/ Copy the tuple value into a user-\/provided array.  
\item {\ttfamily obj.\-Set\-Tuple (vtk\-Id\-Type i, float tuple)} -\/ Set the tuple value at the ith location in the array.  
\item {\ttfamily obj.\-Set\-Tuple (vtk\-Id\-Type i, double tuple)} -\/ Set the tuple value at the ith location in the array.  
\item {\ttfamily obj.\-Insert\-Tuple (vtk\-Id\-Type i, float tuple)} -\/ Insert (memory allocation performed) the tuple into the ith location in the array.  
\item {\ttfamily obj.\-Insert\-Tuple (vtk\-Id\-Type i, double tuple)} -\/ Insert (memory allocation performed) the tuple into the ith location in the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Tuple (float tuple)} -\/ Insert (memory allocation performed) the tuple onto the end of the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Tuple (double tuple)} -\/ Insert (memory allocation performed) the tuple onto the end of the array.  
\item {\ttfamily obj.\-Remove\-Tuple (vtk\-Id\-Type id)} -\/ These methods remove tuples from the data array. They shift data and resize array, so the data array is still valid after this operation. Note, this operation is fairly slow.  
\item {\ttfamily obj.\-Remove\-First\-Tuple ()} -\/ These methods remove tuples from the data array. They shift data and resize array, so the data array is still valid after this operation. Note, this operation is fairly slow.  
\item {\ttfamily obj.\-Remove\-Last\-Tuple ()} -\/ These methods remove tuples from the data array. They shift data and resize array, so the data array is still valid after this operation. Note, this operation is fairly slow.  
\item {\ttfamily obj.\-Set\-Component (vtk\-Id\-Type i, int j, double c)} -\/ Set the data component at the ith tuple and jth component location. Note that i is less then Number\-Of\-Tuples and j is less then Number\-Of\-Components. Make sure enough memory has been allocated (use Set\-Number\-Of\-Tuples() and Set\-Number\-Of\-Components()).  
\item {\ttfamily obj.\-Squeeze ()} -\/ Free any unneeded memory.  
\item {\ttfamily int = obj.\-Resize (vtk\-Id\-Type num\-Tuples)} -\/ Resize the array while conserving the data.  
\item {\ttfamily int = obj.\-Get\-Value (vtk\-Id\-Type id)} -\/ Get the data at a particular index.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Values (vtk\-Id\-Type number)} -\/ Fast method based setting of values without memory checks. First use Set\-Number\-Of\-Values then use Set\-Value to actually set them. Specify the number of values for this object to hold. Does an allocation as well as setting the Max\-Id ivar. Used in conjunction with Set\-Value() method for fast insertion.  
\item {\ttfamily obj.\-Set\-Value (vtk\-Id\-Type id, int value)} -\/ Set the data at a particular index. Does not do range checking. Make sure you use the method Set\-Number\-Of\-Values() before inserting data.  
\item {\ttfamily obj.\-Insert\-Value (vtk\-Id\-Type id, int i)} -\/ Insets values and checks to make sure there is enough memory  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Value (int i)}  
\item {\ttfamily obj.\-Insert\-Component (vtk\-Id\-Type i, int j, double c)} -\/ Insert the data component at ith tuple and jth component location. Note that memory allocation is performed as necessary to hold the data.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Data\-Array da)} -\/ Deep copy of another bit array.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Abstract\-Array aa)} -\/ This method lets the user specify data to be held by the array. The array argument is a pointer to the data. size is the size of the array supplied by the user. Set save to 1 to keep the class from deleting the array when it cleans up or reallocates memory. The class uses the actual array provided; it does not copy the data from the suppled array. If save 0, the array must have been allocated with new\mbox{[}\mbox{]} not malloc.  
\item {\ttfamily obj.\-Set\-Array (string array, vtk\-Id\-Type size, int save)} -\/ This method lets the user specify data to be held by the array. The array argument is a pointer to the data. size is the size of the array supplied by the user. Set save to 1 to keep the class from deleting the array when it cleans up or reallocates memory. The class uses the actual array provided; it does not copy the data from the suppled array. If save 0, the array must have been allocated with new\mbox{[}\mbox{]} not malloc.  
\item {\ttfamily vtk\-Array\-Iterator = obj.\-New\-Iterator ()} -\/ Returns a new vtk\-Bit\-Array\-Iterator instance.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Lookup\-Value (int value)}  
\item {\ttfamily obj.\-Lookup\-Value (int value, vtk\-Id\-List ids)}  
\item {\ttfamily obj.\-Data\-Changed ()} -\/ Tell the array explicitly that the data has changed. This is only necessary to call when you modify the array contents without using the array's A\-P\-I (i.\-e. you retrieve a pointer to the data and modify the array contents). You need to call this so that the fast lookup will know to rebuild itself. Otherwise, the lookup functions will give incorrect results.  
\item {\ttfamily obj.\-Clear\-Lookup ()} -\/ Delete the associated fast lookup data structure on this array, if it exists. The lookup will be rebuilt on the next call to a lookup function.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkbox}{}\section{vtk\-Box}\label{vtkcommon_vtkbox}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Box computes the implicit function and/or gradient for a axis-\/aligned bounding box. (The superclasses transform can be used to modify this orientation.) Each side of the box is orthogonal to all other sides meeting along shared edges and all faces are orthogonal to the x-\/y-\/z coordinate axes. (If you wish to orient this box differently, recall that the superclass vtk\-Implicit\-Function supports a transformation matrix.) vtk\-Cube is a concrete implementation of vtk\-Implicit\-Function.

To create an instance of class vtk\-Box, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBox
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Box has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Box class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Box = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Box = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily double = obj.\-Evaluate\-Function (double x\mbox{[}3\mbox{]})}  
\item {\ttfamily double = obj.\-Evaluate\-Function (double x, double y, double z)}  
\item {\ttfamily obj.\-Evaluate\-Gradient (double x\mbox{[}3\mbox{]}, double n\mbox{[}3\mbox{]})}  
\item {\ttfamily obj.\-Set\-X\-Min (double p\mbox{[}3\mbox{]})} -\/ Set / get the bounding box using various methods.  
\item {\ttfamily obj.\-Set\-X\-Min (double x, double y, double z)} -\/ Set / get the bounding box using various methods.  
\item {\ttfamily obj.\-Get\-X\-Min (double p\mbox{[}3\mbox{]})} -\/ Set / get the bounding box using various methods.  
\item {\ttfamily obj.\-Set\-X\-Max (double p\mbox{[}3\mbox{]})}  
\item {\ttfamily obj.\-Set\-X\-Max (double x, double y, double z)}  
\item {\ttfamily obj.\-Get\-X\-Max (double p\mbox{[}3\mbox{]})}  
\item {\ttfamily obj.\-Set\-Bounds (double x\-Min, double x\-Max, double y\-Min, double y\-Max, double z\-Min, double z\-Max)}  
\item {\ttfamily obj.\-Set\-Bounds (double bounds\mbox{[}6\mbox{]})}  
\item {\ttfamily obj.\-Get\-Bounds (double bounds\mbox{[}6\mbox{]})}  
\item {\ttfamily obj.\-Add\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ A special method that allows union set operation on bounding boxes. Start with a Set\-Bounds(). Subsequent Add\-Bounds() methods are union set operations on the original bounds. Retrieve the final bounds with a Get\-Bounds() method.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkboxmuellerrandomsequence}{}\section{vtk\-Box\-Mueller\-Random\-Sequence}\label{vtkcommon_vtkboxmuellerrandomsequence}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Gaussian\-Random\-Sequence is a sequence of pseudo random numbers distributed according to the Gaussian/normal distribution (mean=0 and standard deviation=1).

It based is calculation from a uniformly distributed pseudo random sequence. The initial sequence is a vtk\-Minimal\-Standard\-Random\-Sequence.

To create an instance of class vtk\-Box\-Mueller\-Random\-Sequence, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBoxMuellerRandomSequence
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Box\-Mueller\-Random\-Sequence has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Box\-Mueller\-Random\-Sequence class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Box\-Mueller\-Random\-Sequence = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Box\-Mueller\-Random\-Sequence = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily double = obj.\-Get\-Value ()} -\/ Current value.  
\item {\ttfamily obj.\-Next ()} -\/ Move to the next number in the random sequence.  
\item {\ttfamily vtk\-Random\-Sequence = obj.\-Get\-Uniform\-Sequence ()} -\/ Return the uniformly distributed sequence of random numbers.  
\item {\ttfamily obj.\-Set\-Uniform\-Sequence (vtk\-Random\-Sequence uniform\-Sequence)} -\/ Set the uniformly distributed sequence of random numbers. Default is a .  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkbyteswap}{}\section{vtk\-Byte\-Swap}\label{vtkcommon_vtkbyteswap}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Byte\-Swap is used by other classes to perform machine dependent byte swapping. Byte swapping is often used when reading or writing binary files.

To create an instance of class vtk\-Byte\-Swap, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkByteSwap
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Byte\-Swap has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Byte\-Swap class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Byte\-Swap = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Byte\-Swap = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkchararray}{}\section{vtk\-Char\-Array}\label{vtkcommon_vtkchararray}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Char\-Array is an array of values of type char. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Char\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCharArray
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Char\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Char\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Char\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Char\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()} -\/ Copy the tuple value into a user-\/provided array.  
\item {\ttfamily obj.\-Get\-Tuple\-Value (vtk\-Id\-Type i, string tuple)} -\/ Set the tuple value at the ith location in the array.  
\item {\ttfamily obj.\-Set\-Tuple\-Value (vtk\-Id\-Type i, string tuple)} -\/ Insert (memory allocation performed) the tuple into the ith location in the array.  
\item {\ttfamily obj.\-Insert\-Tuple\-Value (vtk\-Id\-Type i, string tuple)} -\/ Insert (memory allocation performed) the tuple onto the end of the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Tuple\-Value (string tuple)} -\/ Get the data at a particular index.  
\item {\ttfamily char = obj.\-Get\-Value (vtk\-Id\-Type id)} -\/ Set the data at a particular index. Does not do range checking. Make sure you use the method Set\-Number\-Of\-Values() before inserting data.  
\item {\ttfamily obj.\-Set\-Value (vtk\-Id\-Type id, char value)} -\/ Specify the number of values for this object to hold. Does an allocation as well as setting the Max\-Id ivar. Used in conjunction with Set\-Value() method for fast insertion.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Values (vtk\-Id\-Type number)} -\/ Insert data at a specified position in the array.  
\item {\ttfamily obj.\-Insert\-Value (vtk\-Id\-Type id, char f)} -\/ Insert data at the end of the array. Return its location in the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Value (char f)} -\/ Get the address of a particular data index. Make sure data is allocated for the number of items requested. Set Max\-Id according to the number of data values requested.  
\item {\ttfamily string = obj.\-Write\-Pointer (vtk\-Id\-Type id, vtk\-Id\-Type number)} -\/ Get the address of a particular data index. Performs no checks to verify that the memory has been allocated etc.  
\item {\ttfamily string = obj.\-Get\-Pointer (vtk\-Id\-Type id)} -\/ This method lets the user specify data to be held by the array. The array argument is a pointer to the data. size is the size of the array supplied by the user. Set save to 1 to keep the class from deleting the array when it cleans up or reallocates memory. The class uses the actual array provided; it does not copy the data from the suppled array.  
\item {\ttfamily obj.\-Set\-Array (string array, vtk\-Id\-Type size, int save)} -\/ This method lets the user specify data to be held by the array. The array argument is a pointer to the data. size is the size of the array supplied by the user. Set save to 1 to keep the class from deleting the array when it cleans up or reallocates memory. The class uses the actual array provided; it does not copy the data from the suppled array.  
\item {\ttfamily obj.\-Set\-Array (string array, vtk\-Id\-Type size, int save, int delete\-Method)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkcollection}{}\section{vtk\-Collection}\label{vtkcommon_vtkcollection}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Collection is a general object for creating and manipulating lists of objects. The lists are unsorted and allow duplicate entries. vtk\-Collection also serves as a base class for lists of specific types of objects.

To create an instance of class vtk\-Collection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCollection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Collection has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Collection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Collection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Collection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Item (vtk\-Object )} -\/ Add an object to the list. Does not prevent duplicate entries.  
\item {\ttfamily obj.\-Insert\-Item (int i, vtk\-Object )} -\/ Insert item into the list after the i'th item. Does not prevent duplicate entries. If i $<$ 0 the item is placed at the top of the list.  
\item {\ttfamily obj.\-Replace\-Item (int i, vtk\-Object )} -\/ Replace the i'th item in the collection with a  
\item {\ttfamily obj.\-Remove\-Item (int i)} -\/ Remove the i'th item in the list. Be careful if using this function during traversal of the list using Get\-Next\-Item\-As\-Object (or Get\-Next\-Item in derived class). The list W\-I\-L\-L be shortened if a valid index is given! If this-\/$>$Current is equal to the element being removed, have it point to then next element in the list.  
\item {\ttfamily obj.\-Remove\-Item (vtk\-Object )} -\/ Remove an object from the list. Removes the first object found, not all occurrences. If no object found, list is unaffected. See warning in description of Remove\-Item(int).  
\item {\ttfamily obj.\-Remove\-All\-Items ()} -\/ Remove all objects from the list.  
\item {\ttfamily int = obj.\-Is\-Item\-Present (vtk\-Object a)} -\/ Search for an object and return location in list. If the return value is 0, the object was not found. If the object was found, the location is the return value-\/1.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Items ()} -\/ Return the number of objects in the list.  
\item {\ttfamily obj.\-Init\-Traversal ()} -\/ Initialize the traversal of the collection. This means the data pointer is set at the beginning of the list.  
\item {\ttfamily vtk\-Object = obj.\-Get\-Next\-Item\-As\-Object ()} -\/ Get the next item in the collection. N\-U\-L\-L is returned if the collection is exhausted.  
\item {\ttfamily vtk\-Object = obj.\-Get\-Item\-As\-Object (int i)} -\/ Get the i'th item in the collection. N\-U\-L\-L is returned if i is out of range  
\item {\ttfamily vtk\-Collection\-Iterator = obj.\-New\-Iterator ()} -\/ Get an iterator to traverse the objects in this collection.  
\item {\ttfamily obj.\-Register (vtk\-Object\-Base o)} -\/ Participate in garbage collection.  
\item {\ttfamily obj.\-Un\-Register (vtk\-Object\-Base o)} -\/ Participate in garbage collection.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkcollectioniterator}{}\section{vtk\-Collection\-Iterator}\label{vtkcommon_vtkcollectioniterator}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Collection\-Iterator provides an alternative way to traverse through the objects in a vtk\-Collection. Unlike the collection's built in interface, this allows multiple iterators to simultaneously traverse the collection. If items are removed from the collection, only the iterators currently pointing to those items are invalidated. Other iterators will still continue to function normally.

To create an instance of class vtk\-Collection\-Iterator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCollectionIterator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Collection\-Iterator has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Collection\-Iterator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Collection\-Iterator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Collection\-Iterator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Collection (vtk\-Collection )} -\/ Set/\-Get the collection over which to iterate.  
\item {\ttfamily vtk\-Collection = obj.\-Get\-Collection ()} -\/ Set/\-Get the collection over which to iterate.  
\item {\ttfamily obj.\-Init\-Traversal ()} -\/ Position the iterator at the first item in the collection.  
\item {\ttfamily obj.\-Go\-To\-First\-Item ()} -\/ Position the iterator at the first item in the collection.  
\item {\ttfamily obj.\-Go\-To\-Next\-Item ()} -\/ Move the iterator to the next item in the collection.  
\item {\ttfamily int = obj.\-Is\-Done\-With\-Traversal ()} -\/ Test whether the iterator is currently positioned at a valid item. Returns 1 for yes, 0 for no.  
\item {\ttfamily vtk\-Object = obj.\-Get\-Current\-Object ()} -\/ Get the item at the current iterator position. Valid only when Is\-Done\-With\-Traversal() returns 1.  
\item {\ttfamily vtk\-Object = obj.\-Get\-Object ()} -\/  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkconditionvariable}{}\section{vtk\-Condition\-Variable}\label{vtkcommon_vtkconditionvariable}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Condition\-Variable allows the locking of variables which are accessed through different threads. This header file also defines vtk\-Simple\-Condition\-Variable which is not a subclass of vtk\-Object.

The win32 implementation is based on notes provided by Douglas C. Schmidt and Irfan Pyarali, Department of Computer Science, Washington University, St. Louis, Missouri. \href{http://www.cs.wustl.edu/~schmidt/win32-cv-1.html}{\tt http\-://www.\-cs.\-wustl.\-edu/$\sim$schmidt/win32-\/cv-\/1.\-html}

To create an instance of class vtk\-Condition\-Variable, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkConditionVariable
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Condition\-Variable has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Condition\-Variable class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Condition\-Variable = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Condition\-Variable = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Signal ()} -\/ Wake one thread waiting for the condition to change.  
\item {\ttfamily obj.\-Broadcast ()} -\/ Wake all threads waiting for the condition to change.  
\item {\ttfamily int = obj.\-Wait (vtk\-Mutex\-Lock mutex)} -\/ Wait for the condition to change. Upon entry, the mutex must be locked and the lock held by the calling thread. Upon exit, the mutex will be locked and held by the calling thread. Between entry and exit, the mutex will be unlocked and may be held by other threads.


\begin{DoxyParams}{Parameters}
{\em mutex} & The mutex that should be locked on entry and will be locked on exit (but not in between) \\
\hline
\end{DoxyParams}

\begin{DoxyRetVals}{Return values}
{\em Normally,this} & function returns 0. Should a thread be interrupted by a signal, a non-\/zero value may be returned.  \\
\hline
\end{DoxyRetVals}

\end{DoxyItemize}\hypertarget{vtkcommon_vtkcontourvalues}{}\section{vtk\-Contour\-Values}\label{vtkcommon_vtkcontourvalues}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Contour\-Values is a general class to manage the creation, generation, and retrieval of contour values. This class serves as a helper class for contouring classes, or those classes operating on lists of contour values.

To create an instance of class vtk\-Contour\-Values, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkContourValues
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Contour\-Values has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Contour\-Values class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Contour\-Values = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Contour\-Values = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Value (int i, double value)} -\/ Set the ith contour value.  
\item {\ttfamily double = obj.\-Get\-Value (int i)} -\/ Get the ith contour value. The return value will be clamped if the index i is out of range.  
\item {\ttfamily obj.\-Get\-Values (double contour\-Values)} -\/ Fill a supplied list with contour values. Make sure you've allocated memory of size Get\-Number\-Of\-Contours().  
\item {\ttfamily obj.\-Set\-Number\-Of\-Contours (int number)} -\/ Set the number of contours to place into the list. You only really need to use this method to reduce list size. The method Set\-Value() will automatically increase list size as needed.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Contours ()} -\/ Return the number of contours in the  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\mbox{[}2\mbox{]})} -\/ Generate num\-Contours equally spaced contour values between specified range. Contour values will include min/max range values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\-Start, double range\-End)} -\/ Generate num\-Contours equally spaced contour values between specified range. Contour values will include min/max range values.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkcriticalsection}{}\section{vtk\-Critical\-Section}\label{vtkcommon_vtkcriticalsection}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Critical\-Section allows the locking of variables which are accessed through different threads. This header file also defines vtk\-Simple\-Critical\-Section which is not a subclass of vtk\-Object. The A\-P\-I is identical to that of vtk\-Mutex\-Lock, and the behavior is identical as well, except on Windows 9x/\-N\-T platforms. The only difference on these platforms is that vtk\-Mutex\-Lock is more flexible, in that it works across processes as well as across threads, but also costs more, in that it evokes a 600-\/cycle x86 ring transition. The vtk\-Critical\-Section provides a higher-\/performance equivalent (on Windows) but won't work across processes. Since it is unclear how, in vtk, an object at the vtk level can be shared across processes in the first place, one should use vtk\-Critical\-Section unless one has a very good reason to use vtk\-Mutex\-Lock. If higher-\/performance equivalents for non-\/\-Windows platforms (Irix, Sun\-O\-S, etc) are discovered, they should replace the implementations in this class

To create an instance of class vtk\-Critical\-Section, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCriticalSection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Critical\-Section has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Critical\-Section class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Critical\-Section = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Critical\-Section = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Lock ()} -\/ Lock the vtk\-Critical\-Section  
\item {\ttfamily obj.\-Unlock ()} -\/ Unlock the vtk\-Critical\-Section  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkcylindricaltransform}{}\section{vtk\-Cylindrical\-Transform}\label{vtkcommon_vtkcylindricaltransform}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Cylindrical\-Transform will convert (r,theta,z) coordinates to (x,y,z) coordinates and back again. The angles are given in radians. By default, it converts cylindrical coordinates to rectangular, but Get\-Inverse() returns a transform that will do the opposite. The equation that is used is x = r$\ast$cos(theta), y = r$\ast$sin(theta), z = z.

To create an instance of class vtk\-Cylindrical\-Transform, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCylindricalTransform
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Cylindrical\-Transform has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Cylindrical\-Transform class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Cylindrical\-Transform = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Cylindrical\-Transform = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Make\-Transform ()} -\/ Make another transform of the same type.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkdataarray}{}\section{vtk\-Data\-Array}\label{vtkcommon_vtkdataarray}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Data\-Array is an abstract superclass for data array objects containing numeric data. It extends the A\-P\-I defined in vtk\-Abstract\-Array. vtk\-Data\-Array is an abstract superclass for data array objects. This class defines an A\-P\-I that all array objects must support. Note that the concrete subclasses of this class represent data in native form (char, int, etc.) and often have specialized more efficient methods for operating on this data (for example, getting pointers to data or getting/inserting data in native form). Subclasses of vtk\-Data\-Array are assumed to contain data whose components are meaningful when cast to and from double.

To create an instance of class vtk\-Data\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDataArray
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Data\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Data\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Data\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Data\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Is\-Numeric ()} -\/ Return the size, in bytes, of the lowest-\/level element of an array. For vtk\-Data\-Array and subclasses this is the size of the data type.  
\item {\ttfamily int = obj.\-Get\-Element\-Component\-Size ()} -\/ Set the tuple at the ith location using the jth tuple in the source array. This method assumes that the two arrays have the same type and structure. Note that range checking and memory allocation is not performed; use in conjunction with Set\-Number\-Of\-Tuples() to allocate space.  
\item {\ttfamily obj.\-Set\-Tuple (vtk\-Id\-Type i, vtk\-Id\-Type j, vtk\-Abstract\-Array source)} -\/ Set the tuple at the ith location using the jth tuple in the source array. This method assumes that the two arrays have the same type and structure. Note that range checking and memory allocation is not performed; use in conjunction with Set\-Number\-Of\-Tuples() to allocate space.  
\item {\ttfamily obj.\-Insert\-Tuple (vtk\-Id\-Type i, vtk\-Id\-Type j, vtk\-Abstract\-Array source)} -\/ Insert the jth tuple in the source array, at ith location in this array. Note that memory allocation is performed as necessary to hold the data. This pure virtual function is redeclared here to avoid declaration hidden warnings.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Tuple (vtk\-Id\-Type j, vtk\-Abstract\-Array source)} -\/ Insert the jth tuple in the source array, at the end in this array. Note that memory allocation is performed as necessary to hold the data. Returns the location at which the data was inserted. This pure virtual function is redeclared here to avoid declaration hidden warnings.  
\item {\ttfamily obj.\-Get\-Tuples (vtk\-Id\-List pt\-Ids, vtk\-Abstract\-Array output)} -\/ Given a list of point ids, return an array of tuples. You must insure that the output array has been previously allocated with enough space to hold the data.  
\item {\ttfamily obj.\-Get\-Tuples (vtk\-Id\-Type p1, vtk\-Id\-Type p2, vtk\-Abstract\-Array output)} -\/ Get the tuples for the range of points ids specified (i.\-e., p1-\/$>$p2 inclusive). You must insure that the output array has been previously allocated with enough space to hold the data.  
\item {\ttfamily obj.\-Interpolate\-Tuple (vtk\-Id\-Type i, vtk\-Id\-List pt\-Indices, vtk\-Abstract\-Array source, double weights)} -\/ Set the ith tuple in this array as the interpolated tuple value, given the pt\-Indices in the source array and associated interpolation weights. This method assumes that the two arrays are of the same type and strcuture.  
\item {\ttfamily obj.\-Interpolate\-Tuple (vtk\-Id\-Type i, vtk\-Id\-Type id1, vtk\-Abstract\-Array source1, vtk\-Id\-Type id2, vtk\-Abstract\-Array source2, double t)}  
\item {\ttfamily obj.\-Get\-Tuple (vtk\-Id\-Type i, double tuple)} -\/ Get the data tuple at ith location by filling in a user-\/provided array, Make sure that your array is large enough to hold the Number\-Of\-Components amount of data being returned.  
\item {\ttfamily double = obj.\-Get\-Tuple1 (vtk\-Id\-Type i)} -\/ These methods are included as convenience for the wrappers. Get\-Tuple() and Set\-Tuple() which return/take arrays can not be used from wrapped languages. These methods can be used instead.  
\item {\ttfamily double = obj.\-Get\-Tuple2 (vtk\-Id\-Type i)} -\/ These methods are included as convenience for the wrappers. Get\-Tuple() and Set\-Tuple() which return/take arrays can not be used from wrapped languages. These methods can be used instead.  
\item {\ttfamily double = obj.\-Get\-Tuple3 (vtk\-Id\-Type i)} -\/ These methods are included as convenience for the wrappers. Get\-Tuple() and Set\-Tuple() which return/take arrays can not be used from wrapped languages. These methods can be used instead.  
\item {\ttfamily double = obj.\-Get\-Tuple4 (vtk\-Id\-Type i)} -\/ These methods are included as convenience for the wrappers. Get\-Tuple() and Set\-Tuple() which return/take arrays can not be used from wrapped languages. These methods can be used instead.  
\item {\ttfamily double = obj.\-Get\-Tuple9 (vtk\-Id\-Type i)} -\/ These methods are included as convenience for the wrappers. Get\-Tuple() and Set\-Tuple() which return/take arrays can not be used from wrapped languages. These methods can be used instead.  
\item {\ttfamily obj.\-Set\-Tuple (vtk\-Id\-Type i, float tuple)} -\/ Set the data tuple at ith location. Note that range checking or memory allocation is not performed; use this method in conjunction with Set\-Number\-Of\-Tuples() to allocate space.  
\item {\ttfamily obj.\-Set\-Tuple (vtk\-Id\-Type i, double tuple)} -\/ Set the data tuple at ith location. Note that range checking or memory allocation is not performed; use this method in conjunction with Set\-Number\-Of\-Tuples() to allocate space.  
\item {\ttfamily obj.\-Set\-Tuple1 (vtk\-Id\-Type i, double value)} -\/ These methods are included as convenience for the wrappers. Get\-Tuple() and Set\-Tuple() which return/take arrays can not be used from wrapped languages. These methods can be used instead.  
\item {\ttfamily obj.\-Set\-Tuple2 (vtk\-Id\-Type i, double val0, double val1)} -\/ These methods are included as convenience for the wrappers. Get\-Tuple() and Set\-Tuple() which return/take arrays can not be used from wrapped languages. These methods can be used instead.  
\item {\ttfamily obj.\-Set\-Tuple3 (vtk\-Id\-Type i, double val0, double val1, double val2)} -\/ These methods are included as convenience for the wrappers. Get\-Tuple() and Set\-Tuple() which return/take arrays can not be used from wrapped languages. These methods can be used instead.  
\item {\ttfamily obj.\-Set\-Tuple4 (vtk\-Id\-Type i, double val0, double val1, double val2, double val3)} -\/ These methods are included as convenience for the wrappers. Get\-Tuple() and Set\-Tuple() which return/take arrays can not be used from wrapped languages. These methods can be used instead.  
\item {\ttfamily obj.\-Set\-Tuple9 (vtk\-Id\-Type i, double val0, double val1, double val2, double val3, double val4, double val5, double val6, double val7, double val8)} -\/ These methods are included as convenience for the wrappers. Get\-Tuple() and Set\-Tuple() which return/take arrays can not be used from wrapped languages. These methods can be used instead.  
\item {\ttfamily obj.\-Insert\-Tuple (vtk\-Id\-Type i, float tuple)} -\/ Insert the data tuple at ith location. Note that memory allocation is performed as necessary to hold the data.  
\item {\ttfamily obj.\-Insert\-Tuple (vtk\-Id\-Type i, double tuple)} -\/ Insert the data tuple at ith location. Note that memory allocation is performed as necessary to hold the data.  
\item {\ttfamily obj.\-Insert\-Tuple1 (vtk\-Id\-Type i, double value)} -\/ These methods are included as convenience for the wrappers. Insert\-Tuple() which takes arrays can not be used from wrapped languages. These methods can be used instead.  
\item {\ttfamily obj.\-Insert\-Tuple2 (vtk\-Id\-Type i, double val0, double val1)} -\/ These methods are included as convenience for the wrappers. Insert\-Tuple() which takes arrays can not be used from wrapped languages. These methods can be used instead.  
\item {\ttfamily obj.\-Insert\-Tuple3 (vtk\-Id\-Type i, double val0, double val1, double val2)} -\/ These methods are included as convenience for the wrappers. Insert\-Tuple() which takes arrays can not be used from wrapped languages. These methods can be used instead.  
\item {\ttfamily obj.\-Insert\-Tuple4 (vtk\-Id\-Type i, double val0, double val1, double val2, double val3)} -\/ These methods are included as convenience for the wrappers. Insert\-Tuple() which takes arrays can not be used from wrapped languages. These methods can be used instead.  
\item {\ttfamily obj.\-Insert\-Tuple9 (vtk\-Id\-Type i, double val0, double val1, double val2, double val3, double val4, double val5, double val6, double val7, double val8)} -\/ These methods are included as convenience for the wrappers. Insert\-Tuple() which takes arrays can not be used from wrapped languages. These methods can be used instead.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Tuple (float tuple)} -\/ Insert the data tuple at the end of the array and return the location at which the data was inserted. Memory is allocated as necessary to hold the data.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Tuple (double tuple)} -\/ Insert the data tuple at the end of the array and return the location at which the data was inserted. Memory is allocated as necessary to hold the data.  
\item {\ttfamily obj.\-Insert\-Next\-Tuple1 (double value)} -\/ These methods are included as convenience for the wrappers. Insert\-Tuple() which takes arrays can not be used from wrapped languages. These methods can be used instead.  
\item {\ttfamily obj.\-Insert\-Next\-Tuple2 (double val0, double val1)} -\/ These methods are included as convenience for the wrappers. Insert\-Tuple() which takes arrays can not be used from wrapped languages. These methods can be used instead.  
\item {\ttfamily obj.\-Insert\-Next\-Tuple3 (double val0, double val1, double val2)} -\/ These methods are included as convenience for the wrappers. Insert\-Tuple() which takes arrays can not be used from wrapped languages. These methods can be used instead.  
\item {\ttfamily obj.\-Insert\-Next\-Tuple4 (double val0, double val1, double val2, double val3)} -\/ These methods are included as convenience for the wrappers. Insert\-Tuple() which takes arrays can not be used from wrapped languages. These methods can be used instead.  
\item {\ttfamily obj.\-Insert\-Next\-Tuple9 (double val0, double val1, double val2, double val3, double val4, double val5, double val6, double val7, double val8)} -\/ These methods are included as convenience for the wrappers. Insert\-Tuple() which takes arrays can not be used from wrapped languages. These methods can be used instead.  
\item {\ttfamily obj.\-Remove\-Tuple (vtk\-Id\-Type id)} -\/ These methods remove tuples from the data array. They shift data and resize array, so the data array is still valid after this operation. Note, this operation is fairly slow.  
\item {\ttfamily obj.\-Remove\-First\-Tuple ()} -\/ These methods remove tuples from the data array. They shift data and resize array, so the data array is still valid after this operation. Note, this operation is fairly slow.  
\item {\ttfamily obj.\-Remove\-Last\-Tuple ()} -\/ These methods remove tuples from the data array. They shift data and resize array, so the data array is still valid after this operation. Note, this operation is fairly slow.  
\item {\ttfamily double = obj.\-Get\-Component (vtk\-Id\-Type i, int j)} -\/ Return the data component at the ith tuple and jth component location. Note that i is less than Number\-Of\-Tuples and j is less than Number\-Of\-Components.  
\item {\ttfamily obj.\-Set\-Component (vtk\-Id\-Type i, int j, double c)} -\/ Set the data component at the ith tuple and jth component location. Note that i is less than Number\-Of\-Tuples and j is less than Number\-Of\-Components. Make sure enough memory has been allocated (use Set\-Number\-Of\-Tuples() and Set\-Number\-Of\-Components()).  
\item {\ttfamily obj.\-Insert\-Component (vtk\-Id\-Type i, int j, double c)} -\/ Insert the data component at ith tuple and jth component location. Note that memory allocation is performed as necessary to hold the data.  
\item {\ttfamily obj.\-Get\-Data (vtk\-Id\-Type tuple\-Min, vtk\-Id\-Type tuple\-Max, int comp\-Min, int comp\-Max, vtk\-Double\-Array data)} -\/ Get the data as a double array in the range (tuple\-Min,tuple\-Max) and (comp\-Min, comp\-Max). The resulting double array consists of all data in the tuple range specified and only the component range specified. This process typically requires casting the data from native form into doubleing point values. This method is provided as a convenience for data exchange, and is not very fast.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Abstract\-Array aa)} -\/ Deep copy of data. Copies data from different data arrays even if they are different types (using doubleing-\/point exchange).  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Data\-Array da)} -\/ Deep copy of data. Copies data from different data arrays even if they are different types (using doubleing-\/point exchange).  
\item {\ttfamily obj.\-Fill\-Component (int j, double c)} -\/ Fill a component of a data array with a specified value. This method sets the specified component to specified value for all tuples in the data array. This methods can be used to initialize or reinitialize a single component of a multi-\/component array.  
\item {\ttfamily obj.\-Copy\-Component (int j, vtk\-Data\-Array from, int from\-Component)} -\/ Copy a component from one data array into a component on this data array. This method copies the specified component (\char`\"{}from\-Component\char`\"{}) from the specified data array (\char`\"{}from\char`\"{}) to the specified component (\char`\"{}j\char`\"{}) over all the tuples in this data array. This method can be used to extract a component (column) from one data array and paste that data into a component on this data array.  
\item {\ttfamily long = obj.\-Get\-Actual\-Memory\-Size ()} -\/ Return the memory in kilobytes consumed by this data array. Used to support streaming and reading/writing data. The value returned is guaranteed to be greater than or equal to the memory required to actually represent the data represented by this object. The information returned is valid only after the pipeline has been updated.  
\item {\ttfamily obj.\-Create\-Default\-Lookup\-Table ()} -\/ Create default lookup table. Generally used to create one when none is available.  
\item {\ttfamily obj.\-Set\-Lookup\-Table (vtk\-Lookup\-Table lut)} -\/ Set/get the lookup table associated with this scalar data, if any.  
\item {\ttfamily vtk\-Lookup\-Table = obj.\-Get\-Lookup\-Table ()} -\/ Set/get the lookup table associated with this scalar data, if any.  
\item {\ttfamily obj.\-Get\-Range (double range\mbox{[}2\mbox{]}, int comp)} -\/ Return the range of the array values for the given component. Range is copied into the array provided. If comp is equal to -\/1, it returns the range of the magnitude (if the number of components is equal to 1 it still returns the range of component 0).  
\item {\ttfamily double = obj.\-Get\-Range (int comp)} -\/ Return the range of the array values for the 0th component. Range is copied into the array provided.  
\item {\ttfamily double = obj.\-Get\-Range ()} -\/ Return the range of the array values for the 0th component. Range is copied into the array provided.  
\item {\ttfamily obj.\-Get\-Range (double range\mbox{[}2\mbox{]})} -\/ These methods return the Min and Max possible range of the native data type. For example if a vtk\-Scalars consists of unsigned char data these will return (0,255).  
\item {\ttfamily obj.\-Get\-Data\-Type\-Range (double range\mbox{[}2\mbox{]})} -\/ These methods return the Min and Max possible range of the native data type. For example if a vtk\-Scalars consists of unsigned char data these will return (0,255).  
\item {\ttfamily double = obj.\-Get\-Data\-Type\-Min ()} -\/ These methods return the Min and Max possible range of the native data type. For example if a vtk\-Scalars consists of unsigned char data these will return (0,255).  
\item {\ttfamily double = obj.\-Get\-Data\-Type\-Max ()} -\/ These methods return the Min and Max possible range of the native data type. For example if a vtk\-Scalars consists of unsigned char data these will return (0,255).  
\item {\ttfamily double = obj.\-Get\-Max\-Norm ()} -\/ Return the maximum norm for the tuples. Note that the max. is computed everytime Get\-Max\-Norm is called.  
\item {\ttfamily int = obj.\-Copy\-Information (vtk\-Information info\-From, int deep)} -\/ Copy information instance. Arrays use information objects in a variety of ways. It is important to have flexibility in this regard because certain keys should not be coppied, while others must be. N\-O\-T\-E\-: Up to the implmeneter to make sure that keys not inteneded to be coppied are excluded here.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkdataarraycollection}{}\section{vtk\-Data\-Array\-Collection}\label{vtkcommon_vtkdataarraycollection}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Data\-Array\-Collection is an object that creates and manipulates lists of datasets. See also vtk\-Collection and subclasses.

To create an instance of class vtk\-Data\-Array\-Collection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDataArrayCollection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Data\-Array\-Collection has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Data\-Array\-Collection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Data\-Array\-Collection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Data\-Array\-Collection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Item (vtk\-Data\-Array ds)} -\/ Get the next dataarray in the list.  
\item {\ttfamily vtk\-Data\-Array = obj.\-Get\-Next\-Item ()} -\/ Get the next dataarray in the list.  
\item {\ttfamily vtk\-Data\-Array = obj.\-Get\-Item (int i)} -\/ Get the ith dataarray in the list.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkdataarraycollectioniterator}{}\section{vtk\-Data\-Array\-Collection\-Iterator}\label{vtkcommon_vtkdataarraycollectioniterator}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Data\-Array\-Collection\-Iterator provides an implementation of vtk\-Collection\-Iterator which allows the items to be retrieved with the proper subclass pointer type for vtk\-Data\-Array\-Collection.

To create an instance of class vtk\-Data\-Array\-Collection\-Iterator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDataArrayCollectionIterator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Data\-Array\-Collection\-Iterator has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Data\-Array\-Collection\-Iterator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Data\-Array\-Collection\-Iterator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Data\-Array\-Collection\-Iterator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Collection (vtk\-Collection )} -\/ Set the collection over which to iterate.  
\item {\ttfamily obj.\-Set\-Collection (vtk\-Data\-Array\-Collection )} -\/ Set the collection over which to iterate.  
\item {\ttfamily vtk\-Data\-Array = obj.\-Get\-Data\-Array ()} -\/ Get the item at the current iterator position. Valid only when Is\-Done\-With\-Traversal() returns 1.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkdataarrayselection}{}\section{vtk\-Data\-Array\-Selection}\label{vtkcommon_vtkdataarrayselection}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Data\-Array\-Selection can be used by vtk\-Source subclasses to store on/off settings for whether each vtk\-Data\-Array in its input should be passed in the source's output. This is primarily intended to allow file readers to configure what data arrays are read from the file.

To create an instance of class vtk\-Data\-Array\-Selection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDataArraySelection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Data\-Array\-Selection has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Data\-Array\-Selection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Data\-Array\-Selection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Data\-Array\-Selection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Enable\-Array (string name)} -\/ Enable the array with the given name. Creates a new entry if none exists.  
\item {\ttfamily obj.\-Disable\-Array (string name)} -\/ Disable the array with the given name. Creates a new entry if none exists.  
\item {\ttfamily int = obj.\-Array\-Is\-Enabled (string name)} -\/ Return whether the array with the given name is enabled. If there is no entry, the array is assumed to be disabled.  
\item {\ttfamily int = obj.\-Array\-Exists (string name)} -\/ Return whether the array with the given name exists.  
\item {\ttfamily obj.\-Enable\-All\-Arrays ()} -\/ Enable all arrays that currently have an entry.  
\item {\ttfamily obj.\-Disable\-All\-Arrays ()} -\/ Disable all arrays that currently have an entry.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Arrays ()} -\/ Get the number of arrays that currently have an entry.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Arrays\-Enabled ()} -\/ Get the number of arrays that are enabled.  
\item {\ttfamily string = obj.\-Get\-Array\-Name (int index)} -\/ Get the name of the array entry at the given index.  
\item {\ttfamily int = obj.\-Get\-Array\-Index (string name)} -\/ Get an index of the array containing name within the enabled arrays  
\item {\ttfamily int = obj.\-Get\-Enabled\-Array\-Index (string name)} -\/ Get the index of an array with the given name among those that are enabled. Returns -\/1 if the array is not enabled.  
\item {\ttfamily int = obj.\-Get\-Array\-Setting (string name)} -\/ Get whether the array at the given index is enabled.  
\item {\ttfamily int = obj.\-Get\-Array\-Setting (int index)} -\/ Get whether the array at the given index is enabled.  
\item {\ttfamily obj.\-Remove\-All\-Arrays ()} -\/ Remove all array entries.  
\item {\ttfamily obj.\-Copy\-Selections (vtk\-Data\-Array\-Selection selections)} -\/ Copy the selections from the given vtk\-Data\-Array\-Selection instance.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkdebugleaks}{}\section{vtk\-Debug\-Leaks}\label{vtkcommon_vtkdebugleaks}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Debug\-Leaks is used to report memory leaks at the exit of the program. It uses the vtk\-Object\-Factory to intercept the construction of all V\-T\-K objects. It uses the Un\-Register method of vtk\-Object to intercept the destruction of all objects. A table of object name to number of instances is kept. At the exit of the program if there are still V\-T\-K objects around it will print them out. To enable this class add the flag -\/\-D\-V\-T\-K\-\_\-\-D\-E\-B\-U\-G\-\_\-\-L\-E\-A\-K\-S to the compile line, and rebuild vtk\-Object and vtk\-Object\-Factory.

To create an instance of class vtk\-Debug\-Leaks, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDebugLeaks
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Debug\-Leaks has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Debug\-Leaks class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Debug\-Leaks = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Debug\-Leaks = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkdirectory}{}\section{vtk\-Directory}\label{vtkcommon_vtkdirectory}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Directory provides a portable way of finding the names of the files in a system directory. It also provides methods of manipulating directories.

To create an instance of class vtk\-Directory, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDirectory
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Directory has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Directory class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Return the class name as a string.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Return the class name as a string.  
\item {\ttfamily vtk\-Directory = obj.\-New\-Instance ()} -\/ Return the class name as a string.  
\item {\ttfamily vtk\-Directory = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Return the class name as a string.  
\item {\ttfamily int = obj.\-Open (string dir)} -\/ Open the specified directory and load the names of the files in that directory. 0 is returned if the directory can not be opened, 1 if it is opened.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Files ()} -\/ Return the number of files in the current directory.  
\item {\ttfamily string = obj.\-Get\-File (vtk\-Id\-Type index)} -\/ Return the file at the given index, the indexing is 0 based  
\item {\ttfamily int = obj.\-File\-Is\-Directory (string name)} -\/ Return true if the file is a directory. If the file is not an absolute path, it is assumed to be relative to the opened directory. If no directory has been opened, it is assumed to be relative to the current working directory.  
\item {\ttfamily vtk\-String\-Array = obj.\-Get\-Files ()} -\/ Get an array that contains all the file names.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkdoublearray}{}\section{vtk\-Double\-Array}\label{vtkcommon_vtkdoublearray}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Double\-Array is an array of values of type double. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Double\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDoubleArray
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Double\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Double\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Double\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Double\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()} -\/ Copy the tuple value into a user-\/provided array.  
\item {\ttfamily obj.\-Get\-Tuple\-Value (vtk\-Id\-Type i, double tuple)} -\/ Set the tuple value at the ith location in the array.  
\item {\ttfamily obj.\-Set\-Tuple\-Value (vtk\-Id\-Type i, double tuple)} -\/ Insert (memory allocation performed) the tuple into the ith location in the array.  
\item {\ttfamily obj.\-Insert\-Tuple\-Value (vtk\-Id\-Type i, double tuple)} -\/ Insert (memory allocation performed) the tuple onto the end of the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Tuple\-Value (double tuple)} -\/ Get the data at a particular index.  
\item {\ttfamily double = obj.\-Get\-Value (vtk\-Id\-Type id)} -\/ Set the data at a particular index. Does not do range checking. Make sure you use the method Set\-Number\-Of\-Values() before inserting data.  
\item {\ttfamily obj.\-Set\-Value (vtk\-Id\-Type id, double value)} -\/ Specify the number of values for this object to hold. Does an allocation as well as setting the Max\-Id ivar. Used in conjunction with Set\-Value() method for fast insertion.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Values (vtk\-Id\-Type number)} -\/ Insert data at a specified position in the array.  
\item {\ttfamily obj.\-Insert\-Value (vtk\-Id\-Type id, double f)} -\/ Insert data at the end of the array. Return its location in the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Value (double f)} -\/ Get the address of a particular data index. Make sure data is allocated for the number of items requested. Set Max\-Id according to the number of data values requested.  
\item {\ttfamily obj.\-Set\-Array (double array, vtk\-Id\-Type size, int save)} -\/ This method lets the user specify data to be held by the array. The array argument is a pointer to the data. size is the size of the array supplied by the user. Set save to 1 to keep the class from deleting the array when it cleans up or reallocates memory. The class uses the actual array provided; it does not copy the data from the suppled array.  
\item {\ttfamily obj.\-Set\-Array (double array, vtk\-Id\-Type size, int save, int delete\-Method)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkdynamicloader}{}\section{vtk\-Dynamic\-Loader}\label{vtkcommon_vtkdynamicloader}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Dynamic\-Loader provides a portable interface to loading dynamic libraries into a process.

To create an instance of class vtk\-Dynamic\-Loader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDynamicLoader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Dynamic\-Loader has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Dynamic\-Loader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Dynamic\-Loader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Dynamic\-Loader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkedgetable}{}\section{vtk\-Edge\-Table}\label{vtkcommon_vtkedgetable}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Edge\-Table is a general object for keeping track of lists of edges. An edge is defined by the pair of point id's (p1,p2). Methods are available to insert edges, check if edges exist, and traverse the list of edges. Also, it's possible to associate attribute information with each edge. The attribute information may take the form of vtk\-Id\-Type id's, void$\ast$ pointers, or points. To store attributes, make sure that Init\-Edge\-Insertion() is invoked with the store\-Attributes flag set properly. If points are inserted, use the methods Init\-Point\-Insertion() and Insert\-Unique\-Point().

To create an instance of class vtk\-Edge\-Table, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkEdgeTable
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Edge\-Table has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Edge\-Table class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Edge\-Table = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Edge\-Table = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Initialize ()} -\/ Free memory and return to the initially instantiated state.  
\item {\ttfamily int = obj.\-Init\-Edge\-Insertion (vtk\-Id\-Type num\-Points, int store\-Attributes)} -\/ Initialize the edge insertion process. Provide an estimate of the number of points in a dataset (the maximum range value of p1 or p2). The store\-Attributes variable controls whether attributes are to be stored with the edge, and what type of attributes. If store\-Attributes==1, then attributes of vtk\-Id\-Type can be stored. If store\-Attributes==2, then attributes of type void$\ast$ can be stored. In either case, additional memory will be required by the data structure to store attribute data per each edge. This method is used in conjunction with one of the three Insert\-Edge() methods described below (don't mix the Insert\-Edge() methods---make sure that the one used is consistent with the store\-Attributes flag set in Init\-Edge\-Insertion()).  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Edge (vtk\-Id\-Type p1, vtk\-Id\-Type p2)} -\/ Insert the edge (p1,p2) into the table. It is the user's responsibility to check if the edge has already been inserted (use Is\-Edge()). If the store\-Attributes flag in Init\-Edge\-Insertion() has been set, then the method returns a unique integer id (i.\-e., the edge id) that can be used to set and get edge attributes. Otherwise, the method will return 1. Do not mix this method with the Insert\-Edge() method that follows.  
\item {\ttfamily obj.\-Insert\-Edge (vtk\-Id\-Type p1, vtk\-Id\-Type p2, vtk\-Id\-Type attribute\-Id)} -\/ Insert the edge (p1,p2) into the table with the attribute id specified (make sure the attribute\-Id $>$= 0). Note that the attribute\-Id is ignored if the store\-Attributes variable was set to 0 in the Init\-Edge\-Insertion() method. It is the user's responsibility to check if the edge has already been inserted (use Is\-Edge()). Do not mix this method with the other two Insert\-Edge() methods.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Is\-Edge (vtk\-Id\-Type p1, vtk\-Id\-Type p2)} -\/ Return an integer id for the edge, or an attribute id of the edge (p1,p2) if the edge has been previously defined (it depends upon which version of Insert\-Edge() is being used); otherwise -\/1. The unique integer id can be used to set and retrieve attributes to the edge.  
\item {\ttfamily int = obj.\-Init\-Point\-Insertion (vtk\-Points new\-Pts, vtk\-Id\-Type est\-Size)} -\/ Initialize the point insertion process. The new\-Pts is an object representing point coordinates into which incremental insertion methods place their data. The points are associated with the edge.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Edges ()} -\/ Return the number of edges that have been inserted thus far.  
\item {\ttfamily obj.\-Init\-Traversal ()} -\/ Intialize traversal of edges in table.  
\item {\ttfamily obj.\-Reset ()} -\/ Reset the object and prepare for reinsertion of edges. Does not delete memory like the Initialize() method.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkextentsplitter}{}\section{vtk\-Extent\-Splitter}\label{vtkcommon_vtkextentsplitter}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Extent\-Splitter splits each input extent into non-\/overlapping sub-\/extents that are completely contained within other \char`\"{}source
 extents\char`\"{}. A source extent corresponds to some resource providing an extent. Each source extent has an integer identifier, integer priority, and an extent. The input extents are split into sub-\/extents according to priority, availability, and amount of overlap of the source extents. This can be used by parallel data readers to read as few piece files as possible.

To create an instance of class vtk\-Extent\-Splitter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtentSplitter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extent\-Splitter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extent\-Splitter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extent\-Splitter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extent\-Splitter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Extent\-Source (int id, int priority, int x0, int x1, int y0, int y1, int z0, int z1)} -\/ Add/\-Remove a source providing the given extent. Sources with higher priority numbers are favored. Source id numbers and priorities must be non-\/negative.  
\item {\ttfamily obj.\-Add\-Extent\-Source (int id, int priority, int extent)} -\/ Add/\-Remove a source providing the given extent. Sources with higher priority numbers are favored. Source id numbers and priorities must be non-\/negative.  
\item {\ttfamily obj.\-Remove\-Extent\-Source (int id)} -\/ Add/\-Remove a source providing the given extent. Sources with higher priority numbers are favored. Source id numbers and priorities must be non-\/negative.  
\item {\ttfamily obj.\-Remove\-All\-Extent\-Sources ()} -\/ Add/\-Remove a source providing the given extent. Sources with higher priority numbers are favored. Source id numbers and priorities must be non-\/negative.  
\item {\ttfamily obj.\-Add\-Extent (int x0, int x1, int y0, int y1, int z0, int z1)} -\/ Add an extent to the queue of extents to be split among the available sources.  
\item {\ttfamily obj.\-Add\-Extent (int extent)} -\/ Add an extent to the queue of extents to be split among the available sources.  
\item {\ttfamily int = obj.\-Compute\-Sub\-Extents ()} -\/ Split the extents currently in the queue among the available sources. The queue is empty when this returns. Returns 1 if all extents could be read. Returns 0 if any portion of any extent was not available through any source.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Sub\-Extents ()} -\/ Get the number of sub-\/extents into which the original set of extents have been split across the available sources. Valid after a call to Compute\-Sub\-Extents.  
\item {\ttfamily int = obj.\-Get\-Sub\-Extent (int index)} -\/ Get the sub-\/extent associated with the given index. Use Get\-Sub\-Extent\-Source to get the id of the source from which this sub-\/extent should be read. Valid after a call to Compute\-Sub\-Extents.  
\item {\ttfamily obj.\-Get\-Sub\-Extent (int index, int extent)} -\/ Get the sub-\/extent associated with the given index. Use Get\-Sub\-Extent\-Source to get the id of the source from which this sub-\/extent should be read. Valid after a call to Compute\-Sub\-Extents.  
\item {\ttfamily int = obj.\-Get\-Sub\-Extent\-Source (int index)} -\/ Get the id of the source from which the sub-\/extent associated with the given index should be read. Returns -\/1 if no source provides the sub-\/extent.  
\item {\ttfamily int = obj.\-Get\-Point\-Mode ()} -\/ Get/\-Set whether \char`\"{}point mode\char`\"{} is on. In point mode, sub-\/extents are generated to ensure every point in the update request is read, but not necessarily every cell. This can be used when point data are stored in a planar slice per piece with no cell data. The default is O\-F\-F.  
\item {\ttfamily obj.\-Set\-Point\-Mode (int )} -\/ Get/\-Set whether \char`\"{}point mode\char`\"{} is on. In point mode, sub-\/extents are generated to ensure every point in the update request is read, but not necessarily every cell. This can be used when point data are stored in a planar slice per piece with no cell data. The default is O\-F\-F.  
\item {\ttfamily obj.\-Point\-Mode\-On ()} -\/ Get/\-Set whether \char`\"{}point mode\char`\"{} is on. In point mode, sub-\/extents are generated to ensure every point in the update request is read, but not necessarily every cell. This can be used when point data are stored in a planar slice per piece with no cell data. The default is O\-F\-F.  
\item {\ttfamily obj.\-Point\-Mode\-Off ()} -\/ Get/\-Set whether \char`\"{}point mode\char`\"{} is on. In point mode, sub-\/extents are generated to ensure every point in the update request is read, but not necessarily every cell. This can be used when point data are stored in a planar slice per piece with no cell data. The default is O\-F\-F.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkextenttranslator}{}\section{vtk\-Extent\-Translator}\label{vtkcommon_vtkextenttranslator}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Extent\-Translator generates a structured extent from an unstructured extent. It uses a recursive scheme that splits the largest axis. A hard coded extent can be used for a starting point.

To create an instance of class vtk\-Extent\-Translator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtentTranslator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extent\-Translator has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extent\-Translator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extent\-Translator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extent\-Translator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Whole\-Extent (int , int , int , int , int , int )} -\/ Set the Piece/\-Num\-Pieces. Set the Whole\-Extent and then call Piece\-To\-Extent. The result can be obtained from the Extent ivar.  
\item {\ttfamily obj.\-Set\-Whole\-Extent (int a\mbox{[}6\mbox{]})} -\/ Set the Piece/\-Num\-Pieces. Set the Whole\-Extent and then call Piece\-To\-Extent. The result can be obtained from the Extent ivar.  
\item {\ttfamily int = obj. Get\-Whole\-Extent ()} -\/ Set the Piece/\-Num\-Pieces. Set the Whole\-Extent and then call Piece\-To\-Extent. The result can be obtained from the Extent ivar.  
\item {\ttfamily obj.\-Set\-Extent (int , int , int , int , int , int )} -\/ Set the Piece/\-Num\-Pieces. Set the Whole\-Extent and then call Piece\-To\-Extent. The result can be obtained from the Extent ivar.  
\item {\ttfamily obj.\-Set\-Extent (int a\mbox{[}6\mbox{]})} -\/ Set the Piece/\-Num\-Pieces. Set the Whole\-Extent and then call Piece\-To\-Extent. The result can be obtained from the Extent ivar.  
\item {\ttfamily int = obj. Get\-Extent ()} -\/ Set the Piece/\-Num\-Pieces. Set the Whole\-Extent and then call Piece\-To\-Extent. The result can be obtained from the Extent ivar.  
\item {\ttfamily obj.\-Set\-Piece (int )} -\/ Set the Piece/\-Num\-Pieces. Set the Whole\-Extent and then call Piece\-To\-Extent. The result can be obtained from the Extent ivar.  
\item {\ttfamily int = obj.\-Get\-Piece ()} -\/ Set the Piece/\-Num\-Pieces. Set the Whole\-Extent and then call Piece\-To\-Extent. The result can be obtained from the Extent ivar.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Pieces (int )} -\/ Set the Piece/\-Num\-Pieces. Set the Whole\-Extent and then call Piece\-To\-Extent. The result can be obtained from the Extent ivar.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Pieces ()} -\/ Set the Piece/\-Num\-Pieces. Set the Whole\-Extent and then call Piece\-To\-Extent. The result can be obtained from the Extent ivar.  
\item {\ttfamily obj.\-Set\-Ghost\-Level (int )} -\/ Set the Piece/\-Num\-Pieces. Set the Whole\-Extent and then call Piece\-To\-Extent. The result can be obtained from the Extent ivar.  
\item {\ttfamily int = obj.\-Get\-Ghost\-Level ()} -\/ Set the Piece/\-Num\-Pieces. Set the Whole\-Extent and then call Piece\-To\-Extent. The result can be obtained from the Extent ivar.  
\item {\ttfamily int = obj.\-Piece\-To\-Extent ()} -\/ These are the main methods that should be called. These methods are responsible for converting a piece to an extent. The signatures without arguments are only thread safe when each thread accesses a different instance. The signatures with arguements are fully thread safe.  
\item {\ttfamily int = obj.\-Piece\-To\-Extent\-By\-Points ()} -\/ These are the main methods that should be called. These methods are responsible for converting a piece to an extent. The signatures without arguments are only thread safe when each thread accesses a different instance. The signatures with arguements are fully thread safe.  
\item {\ttfamily int = obj.\-Piece\-To\-Extent\-Thread\-Safe (int piece, int num\-Pieces, int ghost\-Level, int whole\-Extent, int result\-Extent, int split\-Mode, int by\-Points)} -\/ These are the main methods that should be called. These methods are responsible for converting a piece to an extent. The signatures without arguments are only thread safe when each thread accesses a different instance. The signatures with arguements are fully thread safe.  
\item {\ttfamily obj.\-Set\-Split\-Mode\-To\-Block ()} -\/ How should the streamer break up extents. Block mode tries to break an extent up into cube blocks. It always chooses the largest axis to split. Slab mode first breaks up the Z axis. If it gets to one slice, then it starts breaking up other axes.  
\item {\ttfamily obj.\-Set\-Split\-Mode\-To\-X\-Slab ()} -\/ How should the streamer break up extents. Block mode tries to break an extent up into cube blocks. It always chooses the largest axis to split. Slab mode first breaks up the Z axis. If it gets to one slice, then it starts breaking up other axes.  
\item {\ttfamily obj.\-Set\-Split\-Mode\-To\-Y\-Slab ()} -\/ How should the streamer break up extents. Block mode tries to break an extent up into cube blocks. It always chooses the largest axis to split. Slab mode first breaks up the Z axis. If it gets to one slice, then it starts breaking up other axes.  
\item {\ttfamily obj.\-Set\-Split\-Mode\-To\-Z\-Slab ()} -\/ How should the streamer break up extents. Block mode tries to break an extent up into cube blocks. It always chooses the largest axis to split. Slab mode first breaks up the Z axis. If it gets to one slice, then it starts breaking up other axes.  
\item {\ttfamily int = obj.\-Get\-Split\-Mode ()} -\/ How should the streamer break up extents. Block mode tries to break an extent up into cube blocks. It always chooses the largest axis to split. Slab mode first breaks up the Z axis. If it gets to one slice, then it starts breaking up other axes.  
\item {\ttfamily obj.\-Set\-Split\-Path (int len, int splitpath)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkfastnumericconversion}{}\section{vtk\-Fast\-Numeric\-Conversion}\label{vtkcommon_vtkfastnumericconversion}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Fast\-Numeric\-Conversion uses a portable (assuming I\-E\-E\-E format) method for converting single and double precision floating point values to a fixed point representation. This allows fast integer floor operations on platforms, such as Intel X86, in which C\-P\-U floating point conversion algorithms are very slow. It is based on the techniques described in Chris Hecker's article, \char`\"{}\-Let's Get to the (\-Floating) Point\char`\"{}, in Game Developer Magazine, Feb/\-Mar 1996, and the techniques described in Michael Herf's website, \href{http://www.stereopsis.com/FPU.html}{\tt http\-://www.\-stereopsis.\-com/\-F\-P\-U.\-html}. The Hecker article can be found at \href{http://www.d6.com/users/checker/pdfs/gdmfp.pdf}{\tt http\-://www.\-d6.\-com/users/checker/pdfs/gdmfp.\-pdf}. Unfortunately, each of these techniques is incomplete, and doesn't convert properly, in a way that depends on how many bits are reserved for fixed point fractional use, due to failing to properly account for the default round-\/towards-\/even rounding mode of the X86. Thus, my implementation incorporates some rounding correction that undoes the rounding that the F\-P\-U performs during denormalization of the floating point value. Note that the rounding affect I'm talking about here is not the effect on the fistp instruction, but rather the effect that occurs during the denormalization of a value that occurs when adding it to a much larger value. The bits must be shifted to the right, and when a \char`\"{}1\char`\"{} bit falls off the edge, the rounding mode determines what happens next, in order to avoid completely \char`\"{}losing\char`\"{} the 1-\/bit. Furthermore, my implementation works on Linux, where the default precision mode is 64-\/bit extended precision.

To create an instance of class vtk\-Fast\-Numeric\-Conversion, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFastNumericConversion
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Fast\-Numeric\-Conversion has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Fast\-Numeric\-Conversion class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Fast\-Numeric\-Conversion = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Fast\-Numeric\-Conversion = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Test\-Quick\-Floor (double val)} -\/ Wrappable method for script-\/testing of correct cross-\/platform functionality  
\item {\ttfamily int = obj.\-Test\-Safe\-Floor (double val)} -\/ Wrappable method for script-\/testing of correct cross-\/platform functionality  
\item {\ttfamily int = obj.\-Test\-Round (double val)} -\/ Wrappable method for script-\/testing of correct cross-\/platform functionality  
\item {\ttfamily int = obj.\-Test\-Convert\-Fixed\-Point\-Int\-Part (double val)} -\/ Wrappable method for script-\/testing of correct cross-\/platform functionality  
\item {\ttfamily int = obj.\-Test\-Convert\-Fixed\-Point\-Frac\-Part (double val)} -\/ Wrappable method for script-\/testing of correct cross-\/platform functionality  
\item {\ttfamily obj.\-Set\-Reserved\-Frac\-Bits (int bits)} -\/ Set the number of bits reserved for fractional precision that are maintained as part of the flooring process. This number affects the flooring arithmetic. It may be useful if the factional part is to be used to index into a lookup table of some sort. However, if you are only interested in knowing the fractional remainder after flooring, there doesn't appear to be any advantage to using these bits, either in terms of a lookup table, or by directly multiplying by some unit fraction, over simply subtracting the floored value from the original value. Note that since only 32 bits are used for the entire fixed point representation, increasing the number of reserved fractional bits reduces the range of integer values that can be floored to. Add one to the requested number of fractional bits, to make the conversion safe with respect to rounding mode. This is the same as the difference between Quick\-Floor and Safe\-Floor.  
\item {\ttfamily obj.\-Performance\-Tests (void )} -\/ Conduct timing tests so that the usefulness of this class can be ascertained on whatever platform it is being used. Output can be retrieved via Print method.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkfileoutputwindow}{}\section{vtk\-File\-Output\-Window}\label{vtkcommon_vtkfileoutputwindow}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Writes debug/warning/error output to a log file instead of the console. To use this class, instantiate it and then call Set\-Instance(this).

To create an instance of class vtk\-File\-Output\-Window, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFileOutputWindow
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-File\-Output\-Window has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-File\-Output\-Window class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-File\-Output\-Window = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-File\-Output\-Window = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Display\-Text (string )} -\/ Put the text into the log file. New lines are converted to carriage return new lines.  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Sets the name for the log file.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Sets the name for the log file.  
\item {\ttfamily obj.\-Set\-Flush (int )} -\/ Turns on buffer flushing for the output to the log file.  
\item {\ttfamily int = obj.\-Get\-Flush ()} -\/ Turns on buffer flushing for the output to the log file.  
\item {\ttfamily obj.\-Flush\-On ()} -\/ Turns on buffer flushing for the output to the log file.  
\item {\ttfamily obj.\-Flush\-Off ()} -\/ Turns on buffer flushing for the output to the log file.  
\item {\ttfamily obj.\-Set\-Append (int )} -\/ Setting append will cause the log file to be opened in append mode. Otherwise, if the log file exists, it will be overwritten each time the vtk\-File\-Output\-Window is created.  
\item {\ttfamily int = obj.\-Get\-Append ()} -\/ Setting append will cause the log file to be opened in append mode. Otherwise, if the log file exists, it will be overwritten each time the vtk\-File\-Output\-Window is created.  
\item {\ttfamily obj.\-Append\-On ()} -\/ Setting append will cause the log file to be opened in append mode. Otherwise, if the log file exists, it will be overwritten each time the vtk\-File\-Output\-Window is created.  
\item {\ttfamily obj.\-Append\-Off ()} -\/ Setting append will cause the log file to be opened in append mode. Otherwise, if the log file exists, it will be overwritten each time the vtk\-File\-Output\-Window is created.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkfloatarray}{}\section{vtk\-Float\-Array}\label{vtkcommon_vtkfloatarray}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Float\-Array is an array of values of type float. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Float\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFloatArray
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Float\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Float\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Float\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Float\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()} -\/ Copy the tuple value into a user-\/provided array.  
\item {\ttfamily obj.\-Get\-Tuple\-Value (vtk\-Id\-Type i, float tuple)} -\/ Set the tuple value at the ith location in the array.  
\item {\ttfamily obj.\-Set\-Tuple\-Value (vtk\-Id\-Type i, float tuple)} -\/ Insert (memory allocation performed) the tuple into the ith location in the array.  
\item {\ttfamily obj.\-Insert\-Tuple\-Value (vtk\-Id\-Type i, float tuple)} -\/ Insert (memory allocation performed) the tuple onto the end of the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Tuple\-Value (float tuple)} -\/ Get the data at a particular index.  
\item {\ttfamily float = obj.\-Get\-Value (vtk\-Id\-Type id)} -\/ Set the data at a particular index. Does not do range checking. Make sure you use the method Set\-Number\-Of\-Values() before inserting data.  
\item {\ttfamily obj.\-Set\-Value (vtk\-Id\-Type id, float value)} -\/ Specify the number of values for this object to hold. Does an allocation as well as setting the Max\-Id ivar. Used in conjunction with Set\-Value() method for fast insertion.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Values (vtk\-Id\-Type number)} -\/ Insert data at a specified position in the array.  
\item {\ttfamily obj.\-Insert\-Value (vtk\-Id\-Type id, float f)} -\/ Insert data at the end of the array. Return its location in the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Value (float f)} -\/ Get the address of a particular data index. Make sure data is allocated for the number of items requested. Set Max\-Id according to the number of data values requested.  
\item {\ttfamily obj.\-Set\-Array (float array, vtk\-Id\-Type size, int save)} -\/ This method lets the user specify data to be held by the array. The array argument is a pointer to the data. size is the size of the array supplied by the user. Set save to 1 to keep the class from deleting the array when it cleans up or reallocates memory. The class uses the actual array provided; it does not copy the data from the suppled array.  
\item {\ttfamily obj.\-Set\-Array (float array, vtk\-Id\-Type size, int save, int delete\-Method)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkfunctionparser}{}\section{vtk\-Function\-Parser}\label{vtkcommon_vtkfunctionparser}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Function\-Parser is a class that takes in a mathematical expression as a char string, parses it, and evaluates it at the specified values of the variables in the input string.

You can use the \char`\"{}if\char`\"{} operator to create conditional expressions such as if ( test, trueresult, falseresult). These evaluate the boolean valued test expression and then evaluate either the trueresult or the falseresult expression to produce a final (scalar or vector valued) value. \char`\"{}test\char`\"{} may contain $<$,$>$,=,$|$,\&, and () and all three subexpressions can evaluate arbitrary function operators (ln, cos, +, if, etc)

.S\-E\-C\-T\-I\-O\-N Thanks Thomas Dunne (\href{mailto:thomas.dunne@iwr.uni-heidelberg.de}{\tt thomas.\-dunne@iwr.\-uni-\/heidelberg.\-de}) for adding code for two-\/parameter-\/parsing and a few functions (sign, min, max).

Sid Sydoriak (\href{mailto:sxs@lanl.gov}{\tt sxs@lanl.\-gov}) for adding boolean operations and conditional expressions and for fixing a variety of bugs.

To create an instance of class vtk\-Function\-Parser, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFunctionParser
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Function\-Parser has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Function\-Parser class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Function\-Parser = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Function\-Parser = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Function (string function)}  
\item {\ttfamily string = obj.\-Get\-Function ()}  
\item {\ttfamily int = obj.\-Is\-Scalar\-Result ()} -\/ Check whether the result is a scalar result. If it isn't, then either the result is a vector or an error has occurred.  
\item {\ttfamily int = obj.\-Is\-Vector\-Result ()} -\/ Check whether the result is a vector result. If it isn't, then either the result is scalar or an error has occurred.  
\item {\ttfamily double = obj.\-Get\-Scalar\-Result ()} -\/ Get a scalar result from evaluating the input function.  
\item {\ttfamily double = obj.\-Get\-Vector\-Result ()} -\/ Get a vector result from evaluating the input function.  
\item {\ttfamily obj.\-Get\-Vector\-Result (double result\mbox{[}3\mbox{]})} -\/ Get a vector result from evaluating the input function.  
\item {\ttfamily obj.\-Set\-Scalar\-Variable\-Value (string variable\-Name, double value)} -\/ Set the value of a scalar variable. If a variable with this name exists, then its value will be set to the new value. If there is not already a variable with this name, variable\-Name will be added to the list of variables, and its value will be set to the new value.  
\item {\ttfamily obj.\-Set\-Scalar\-Variable\-Value (int i, double value)} -\/ Set the value of a scalar variable. If a variable with this name exists, then its value will be set to the new value. If there is not already a variable with this name, variable\-Name will be added to the list of variables, and its value will be set to the new value.  
\item {\ttfamily double = obj.\-Get\-Scalar\-Variable\-Value (string variable\-Name)} -\/ Get the value of a scalar variable.  
\item {\ttfamily double = obj.\-Get\-Scalar\-Variable\-Value (int i)} -\/ Get the value of a scalar variable.  
\item {\ttfamily obj.\-Set\-Vector\-Variable\-Value (string variable\-Name, double x\-Value, double y\-Value, double z\-Value)} -\/ Set the value of a vector variable. If a variable with this name exists, then its value will be set to the new value. If there is not already a variable with this name, variable\-Name will be added to the list of variables, and its value will be set to the new value.  
\item {\ttfamily obj.\-Set\-Vector\-Variable\-Value (string variable\-Name, double values\mbox{[}3\mbox{]})} -\/ Set the value of a vector variable. If a variable with this name exists, then its value will be set to the new value. If there is not already a variable with this name, variable\-Name will be added to the list of variables, and its value will be set to the new value.  
\item {\ttfamily obj.\-Set\-Vector\-Variable\-Value (int i, double x\-Value, double y\-Value, double z\-Value)} -\/ Set the value of a vector variable. If a variable with this name exists, then its value will be set to the new value. If there is not already a variable with this name, variable\-Name will be added to the list of variables, and its value will be set to the new value.  
\item {\ttfamily obj.\-Set\-Vector\-Variable\-Value (int i, double values\mbox{[}3\mbox{]})} -\/ Set the value of a vector variable. If a variable with this name exists, then its value will be set to the new value. If there is not already a variable with this name, variable\-Name will be added to the list of variables, and its value will be set to the new value.  
\item {\ttfamily double = obj.\-Get\-Vector\-Variable\-Value (string variable\-Name)} -\/ Get the value of a vector variable.  
\item {\ttfamily obj.\-Get\-Vector\-Variable\-Value (string variable\-Name, double value\mbox{[}3\mbox{]})} -\/ Get the value of a vector variable.  
\item {\ttfamily double = obj.\-Get\-Vector\-Variable\-Value (int i)} -\/ Get the value of a vector variable.  
\item {\ttfamily obj.\-Get\-Vector\-Variable\-Value (int i, double value\mbox{[}3\mbox{]})} -\/ Get the value of a vector variable.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Scalar\-Variables ()} -\/ Get the number of scalar variables.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Vector\-Variables ()} -\/ Get the number of vector variables.  
\item {\ttfamily string = obj.\-Get\-Scalar\-Variable\-Name (int i)} -\/ Get the ith scalar variable name.  
\item {\ttfamily string = obj.\-Get\-Vector\-Variable\-Name (int i)} -\/ Get the ith vector variable name.  
\item {\ttfamily obj.\-Remove\-All\-Variables ()} -\/ Remove all the current variables.  
\item {\ttfamily obj.\-Remove\-Scalar\-Variables ()} -\/ Remove all the scalar variables.  
\item {\ttfamily obj.\-Remove\-Vector\-Variables ()} -\/ Remove all the vector variables.  
\item {\ttfamily obj.\-Set\-Replace\-Invalid\-Values (int )} -\/ When Replace\-Invalid\-Values is on, all invalid values (such as sqrt(-\/2), note that function parser does not handle complex numbers) will be replaced by Replacement\-Value. Otherwise an error will be reported  
\item {\ttfamily int = obj.\-Get\-Replace\-Invalid\-Values ()} -\/ When Replace\-Invalid\-Values is on, all invalid values (such as sqrt(-\/2), note that function parser does not handle complex numbers) will be replaced by Replacement\-Value. Otherwise an error will be reported  
\item {\ttfamily obj.\-Replace\-Invalid\-Values\-On ()} -\/ When Replace\-Invalid\-Values is on, all invalid values (such as sqrt(-\/2), note that function parser does not handle complex numbers) will be replaced by Replacement\-Value. Otherwise an error will be reported  
\item {\ttfamily obj.\-Replace\-Invalid\-Values\-Off ()} -\/ When Replace\-Invalid\-Values is on, all invalid values (such as sqrt(-\/2), note that function parser does not handle complex numbers) will be replaced by Replacement\-Value. Otherwise an error will be reported  
\item {\ttfamily obj.\-Set\-Replacement\-Value (double )} -\/ When Replace\-Invalid\-Values is on, all invalid values (such as sqrt(-\/2), note that function parser does not handle complex numbers) will be replaced by Replacement\-Value. Otherwise an error will be reported  
\item {\ttfamily double = obj.\-Get\-Replacement\-Value ()} -\/ When Replace\-Invalid\-Values is on, all invalid values (such as sqrt(-\/2), note that function parser does not handle complex numbers) will be replaced by Replacement\-Value. Otherwise an error will be reported  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkfunctionset}{}\section{vtk\-Function\-Set}\label{vtkcommon_vtkfunctionset}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Function\-Set specifies an abstract interface for set of functions of the form F\-\_\-i = F\-\_\-i(x\-\_\-j) where F (with i=1..m) are the functions and x (with j=1..n) are the independent variables. The only supported operation is the function evaluation at x\-\_\-j.

To create an instance of class vtk\-Function\-Set, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFunctionSet
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Function\-Set has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Function\-Set class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Function\-Set = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Function\-Set = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Function\-Values (double x, double f)} -\/ Evaluate functions at x\-\_\-j. x and f have to point to valid double arrays of appropriate sizes obtained with Get\-Number\-Of\-Functions() and Get\-Number\-Of\-Independent\-Variables.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Functions ()} -\/ Return the number of independent variables. Note that this is constant for a given type of set of functions and can not be changed at run time.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Independent\-Variables ()}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkgarbagecollector}{}\section{vtk\-Garbage\-Collector}\label{vtkcommon_vtkgarbagecollector}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Garbage\-Collector is used by V\-T\-K classes that may be involved in reference counting loops (such as Algorithm $<$-\/$>$ Executive). It detects strongly connected components of the reference graph that have been leaked deletes them. The garbage collector uses the Report\-References method to search the reference graph and construct a net reference count for each connected component. If the net reference count is zero the entire set of objects is deleted. Deleting each component may leak other components, which are then collected recursively.

To enable garbage collection for a class, add these members\-:

\begin{DoxyVerb}  public:
   virtual void Register(vtkObjectBase* o)
     {
     this->RegisterInternal(o, 1);
     }
   virtual void UnRegister(vtkObjectBase* o)
     {
     this->UnRegisterInternal(o, 1);
     }

  protected:

   virtual void ReportReferences(vtkGarbageCollector* collector)
     {
     // Report references held by this object that may be in a loop.
     this->Superclass::ReportReferences(collector);
     vtkGarbageCollectorReport(collector, this->OtherObject, "Other Object");
     }\end{DoxyVerb}


The implementations should be in the .cxx file in practice. It is important that the reference be reported using the real pointer or smart pointer instance that holds the reference. When collecting the garbage collector will actually set this pointer to N\-U\-L\-L. The destructor of the class should be written to deal with this. It is also expected that an invariant is maintained for any reference that is reported. The variable holding the reference must always either be N\-U\-L\-L or refer to a fully constructed valid object. Therefore code like \char`\"{}this-\/$>$\-Object-\/$>$\-Un\-Register(this)\char`\"{} must be avoided if \char`\"{}this-\/$>$\-Object\char`\"{} is a reported reference because it is possible that the object is deleted before Un\-Register returns but then \char`\"{}this-\/$>$\-Object\char`\"{} will be left as a dangling pointer. Instead use code like

\begin{DoxyVerb}   vtkObjectBase* obj = this->Object;
   this->Object = 0;
   obj->UnRegister(this);\end{DoxyVerb}


so that the reported reference maintains the invariant.

If subclassing from a class that already supports garbage collection, one need only provide the Report\-References method.

To create an instance of class vtk\-Garbage\-Collector, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGarbageCollector
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Garbage\-Collector has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Garbage\-Collector class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Garbage\-Collector = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Garbage\-Collector = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkgaussianrandomsequence}{}\section{vtk\-Gaussian\-Random\-Sequence}\label{vtkcommon_vtkgaussianrandomsequence}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Gaussian\-Random\-Sequence is a sequence of pseudo random numbers distributed according to the Gaussian/normal distribution (mean=0 and standard deviation=1)

This is just an interface.

To create an instance of class vtk\-Gaussian\-Random\-Sequence, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGaussianRandomSequence
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Gaussian\-Random\-Sequence has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Gaussian\-Random\-Sequence class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Gaussian\-Random\-Sequence = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Gaussian\-Random\-Sequence = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily double = obj.\-Get\-Scaled\-Value (double mean, double standard\-Deviation)} -\/ Convenient method to return a value given the mean and standard deviation of the Gaussian distribution from the the Gaussian distribution of mean=0 and standard deviation=1.\-0. There is an initial implementation that can be overridden by a subclass.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkgeneraltransform}{}\section{vtk\-General\-Transform}\label{vtkcommon_vtkgeneraltransform}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-General\-Transform is like vtk\-Transform and vtk\-Perspective\-Transform, but it will work with any vtk\-Abstract\-Transform as input. It is not as efficient as the other two, however, because arbitrary transformations cannot be concatenated by matrix multiplication. Transform concatenation is simulated by passing each input point through each transform in turn.

To create an instance of class vtk\-General\-Transform, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGeneralTransform
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-General\-Transform has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-General\-Transform class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-General\-Transform = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-General\-Transform = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Identity ()} -\/ Set this transformation to the identity transformation. If the transform has an Input, then the transformation will be reset so that it is the same as the Input.  
\item {\ttfamily obj.\-Inverse ()} -\/ Invert the transformation. This will also set a flag so that the transformation will use the inverse of its Input, if an Input has been set.  
\item {\ttfamily obj.\-Translate (double x, double y, double z)} -\/ Create a translation matrix and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Translate (double x\mbox{[}3\mbox{]})} -\/ Create a translation matrix and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Translate (float x\mbox{[}3\mbox{]})} -\/ Create a translation matrix and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Rotate\-W\-X\-Y\-Z (double angle, double x, double y, double z)} -\/ Create a rotation matrix and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics. The angle is in degrees, and (x,y,z) specifies the axis that the rotation will be performed around.  
\item {\ttfamily obj.\-Rotate\-W\-X\-Y\-Z (double angle, double axis\mbox{[}3\mbox{]})} -\/ Create a rotation matrix and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics. The angle is in degrees, and (x,y,z) specifies the axis that the rotation will be performed around.  
\item {\ttfamily obj.\-Rotate\-W\-X\-Y\-Z (double angle, float axis\mbox{[}3\mbox{]})} -\/ Create a rotation matrix and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics. The angle is in degrees, and (x,y,z) specifies the axis that the rotation will be performed around.  
\item {\ttfamily obj.\-Rotate\-X (double angle)} -\/ Create a rotation matrix about the X, Y, or Z axis and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics. The angle is expressed in degrees.  
\item {\ttfamily obj.\-Rotate\-Y (double angle)} -\/ Create a rotation matrix about the X, Y, or Z axis and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics. The angle is expressed in degrees.  
\item {\ttfamily obj.\-Rotate\-Z (double angle)} -\/ Create a rotation matrix about the X, Y, or Z axis and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics. The angle is expressed in degrees.  
\item {\ttfamily obj.\-Scale (double x, double y, double z)} -\/ Create a scale matrix (i.\-e. set the diagonal elements to x, y, z) and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Scale (double s\mbox{[}3\mbox{]})} -\/ Create a scale matrix (i.\-e. set the diagonal elements to x, y, z) and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Scale (float s\mbox{[}3\mbox{]})} -\/ Create a scale matrix (i.\-e. set the diagonal elements to x, y, z) and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Concatenate (vtk\-Matrix4x4 matrix)} -\/ Concatenates the matrix with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Concatenate (double elements\mbox{[}16\mbox{]})} -\/ Concatenates the matrix with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Concatenate (vtk\-Abstract\-Transform transform)} -\/ Concatenate the specified transform with the current transformation according to Pre\-Multiply or Post\-Multiply semantics. The concatenation is pipelined, meaning that if any of the transformations are changed, even after Concatenate() is called, those changes will be reflected when you call Transform\-Point().  
\item {\ttfamily obj.\-Pre\-Multiply ()} -\/ Sets the internal state of the transform to Pre\-Multiply. All subsequent operations will occur before those already represented in the current transformation. In homogeneous matrix notation, M = M$\ast$\-A where M is the current transformation matrix and A is the applied matrix. The default is Pre\-Multiply.  
\item {\ttfamily obj.\-Post\-Multiply ()} -\/ Sets the internal state of the transform to Post\-Multiply. All subsequent operations will occur after those already represented in the current transformation. In homogeneous matrix notation, M = A$\ast$\-M where M is the current transformation matrix and A is the applied matrix. The default is Pre\-Multiply.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Concatenated\-Transforms ()} -\/ Get the total number of transformations that are linked into this one via Concatenate() operations or via Set\-Input().  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Get\-Concatenated\-Transform (int i)}  
\item {\ttfamily obj.\-Set\-Input (vtk\-Abstract\-Transform input)} -\/ Set the input for this transformation. This will be used as the base transformation if it is set. This method allows you to build a transform pipeline\-: if the input is modified, then this transformation will automatically update accordingly. Note that the Inverse\-Flag, controlled via Inverse(), determines whether this transformation will use the Input or the inverse of the Input.  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Get\-Input ()} -\/ Set the input for this transformation. This will be used as the base transformation if it is set. This method allows you to build a transform pipeline\-: if the input is modified, then this transformation will automatically update accordingly. Note that the Inverse\-Flag, controlled via Inverse(), determines whether this transformation will use the Input or the inverse of the Input.  
\item {\ttfamily int = obj.\-Get\-Inverse\-Flag ()} -\/ Get the inverse flag of the transformation. This controls whether it is the Input or the inverse of the Input that is used as the base transformation. The Inverse\-Flag is flipped every time Inverse() is called. The Inverse\-Flag is off when a transform is first created.  
\item {\ttfamily obj.\-Push ()} -\/ Pushes the current transformation onto the transformation stack.  
\item {\ttfamily obj.\-Pop ()} -\/ Deletes the transformation on the top of the stack and sets the top to the next transformation on the stack.  
\item {\ttfamily obj.\-Internal\-Transform\-Point (float in\mbox{[}3\mbox{]}, float out\mbox{[}3\mbox{]})} -\/ This will calculate the transformation without calling Update. Meant for use only within other V\-T\-K classes.  
\item {\ttfamily obj.\-Internal\-Transform\-Point (double in\mbox{[}3\mbox{]}, double out\mbox{[}3\mbox{]})} -\/ This will calculate the transformation without calling Update. Meant for use only within other V\-T\-K classes.  
\item {\ttfamily int = obj.\-Circuit\-Check (vtk\-Abstract\-Transform transform)} -\/ Check for self-\/reference. Will return true if concatenating with the specified transform, setting it to be our inverse, or setting it to be our input will create a circular reference. Circuit\-Check is automatically called by Set\-Input(), Set\-Inverse(), and Concatenate(vtk\-X\-Transform $\ast$). Avoid using this function, it is experimental.  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Make\-Transform ()} -\/ Make another transform of the same type.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Override Get\-M\-Time to account for input and concatenation.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkheap}{}\section{vtk\-Heap}\label{vtkcommon_vtkheap}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is a replacement for malloc/free and new/delete for software that has inherent memory leak or performance problems. For example, external software such as the P\-L\-Y library (vtk\-P\-L\-Y) and V\-R\-M\-L importer (vtk\-V\-R\-M\-L\-Importer) are often written with lots of malloc() calls but without the corresponding free() invocations. The class vtk\-Ordered\-Triangulator may create and delete millions of new/delete calls. This class allows the overloading of the C++ new operator (or other memory allocation requests) by using the method Allocate\-Memory(). Memory is deleted with an invocation of Clean\-All() (which deletes A\-L\-L memory; any given memory allocation cannot be deleted). Note\-: a block size can be used to control the size of each memory allocation. Requests for memory are fulfilled from the block until the block runs out, then a new block is created.

To create an instance of class vtk\-Heap, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHeap
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Heap has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Heap class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Heap = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Heap = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Blocks ()} -\/ Get the number of allocations thus far.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Allocations ()} -\/ Get the number of allocations thus far.  
\item {\ttfamily obj.\-Reset ()} -\/ This methods resets the current allocation location back to the beginning of the heap. This allows reuse of previously allocated memory which may be beneficial to performance in many cases.  
\item {\ttfamily string = obj.\-String\-Dup (string str)} -\/ Convenience method performs string duplication.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkhomogeneoustransform}{}\section{vtk\-Homogeneous\-Transform}\label{vtkcommon_vtkhomogeneoustransform}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Homogeneous\-Transform provides a generic interface for homogeneous transformations, i.\-e. transformations which can be represented by multiplying a 4x4 matrix with a homogeneous coordinate.

To create an instance of class vtk\-Homogeneous\-Transform, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHomogeneousTransform
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Homogeneous\-Transform has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Homogeneous\-Transform class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Homogeneous\-Transform = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Homogeneous\-Transform = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Transform\-Points (vtk\-Points in\-Pts, vtk\-Points out\-Pts)} -\/ Apply the transformation to a series of points, and append the results to out\-Pts.  
\item {\ttfamily obj.\-Transform\-Points\-Normals\-Vectors (vtk\-Points in\-Pts, vtk\-Points out\-Pts, vtk\-Data\-Array in\-Nms, vtk\-Data\-Array out\-Nms, vtk\-Data\-Array in\-Vrs, vtk\-Data\-Array out\-Vrs)} -\/ Apply the transformation to a combination of points, normals and vectors.  
\item {\ttfamily obj.\-Get\-Matrix (vtk\-Matrix4x4 m)} -\/ Get a copy of the internal transformation matrix. The transform is Updated first, to guarantee that the matrix is valid.  
\item {\ttfamily vtk\-Matrix4x4 = obj.\-Get\-Matrix ()} -\/ Get a pointer to an internal vtk\-Matrix4x4 that represents the transformation. An Update() is called on the transform to ensure that the matrix is up-\/to-\/date when you get it. You should not store the matrix pointer anywhere because it might become stale.  
\item {\ttfamily vtk\-Homogeneous\-Transform = obj.\-Get\-Homogeneous\-Inverse ()} -\/ This will calculate the transformation without calling Update. Meant for use only within other V\-T\-K classes.  
\item {\ttfamily obj.\-Internal\-Transform\-Point (float in\mbox{[}3\mbox{]}, float out\mbox{[}3\mbox{]})} -\/ This will calculate the transformation without calling Update. Meant for use only within other V\-T\-K classes.  
\item {\ttfamily obj.\-Internal\-Transform\-Point (double in\mbox{[}3\mbox{]}, double out\mbox{[}3\mbox{]})} -\/ This will calculate the transformation without calling Update. Meant for use only within other V\-T\-K classes.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkidentitytransform}{}\section{vtk\-Identity\-Transform}\label{vtkcommon_vtkidentitytransform}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Identity\-Transform is a transformation which will simply pass coordinate data unchanged. All other transform types can also do this, however, the vtk\-Identity\-Transform does so with much greater efficiency.

To create an instance of class vtk\-Identity\-Transform, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkIdentityTransform
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Identity\-Transform has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Identity\-Transform class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Identity\-Transform = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Identity\-Transform = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Transform\-Points (vtk\-Points in\-Pts, vtk\-Points out\-Pts)} -\/ Apply the transformation to a series of points, and append the results to out\-Pts.  
\item {\ttfamily obj.\-Transform\-Normals (vtk\-Data\-Array in\-Nms, vtk\-Data\-Array out\-Nms)} -\/ Apply the transformation to a series of normals, and append the results to out\-Nms.  
\item {\ttfamily obj.\-Transform\-Vectors (vtk\-Data\-Array in\-Vrs, vtk\-Data\-Array out\-Vrs)} -\/ Apply the transformation to a series of vectors, and append the results to out\-Vrs.  
\item {\ttfamily obj.\-Transform\-Points\-Normals\-Vectors (vtk\-Points in\-Pts, vtk\-Points out\-Pts, vtk\-Data\-Array in\-Nms, vtk\-Data\-Array out\-Nms, vtk\-Data\-Array in\-Vrs, vtk\-Data\-Array out\-Vrs)} -\/ Apply the transformation to a combination of points, normals and vectors.  
\item {\ttfamily obj.\-Inverse ()}  
\item {\ttfamily obj.\-Internal\-Transform\-Point (float in\mbox{[}3\mbox{]}, float out\mbox{[}3\mbox{]})} -\/ This will calculate the transformation without calling Update. Meant for use only within other V\-T\-K classes.  
\item {\ttfamily obj.\-Internal\-Transform\-Point (double in\mbox{[}3\mbox{]}, double out\mbox{[}3\mbox{]})} -\/ This will calculate the transformation without calling Update. Meant for use only within other V\-T\-K classes.  
\item {\ttfamily obj.\-Internal\-Transform\-Normal (float in\mbox{[}3\mbox{]}, float out\mbox{[}3\mbox{]})} -\/ This will calculate the transformation without calling Update. Meant for use only within other V\-T\-K classes.  
\item {\ttfamily obj.\-Internal\-Transform\-Normal (double in\mbox{[}3\mbox{]}, double out\mbox{[}3\mbox{]})} -\/ This will calculate the transformation without calling Update. Meant for use only within other V\-T\-K classes.  
\item {\ttfamily obj.\-Internal\-Transform\-Vector (float in\mbox{[}3\mbox{]}, float out\mbox{[}3\mbox{]})} -\/ This will calculate the transformation without calling Update. Meant for use only within other V\-T\-K classes.  
\item {\ttfamily obj.\-Internal\-Transform\-Vector (double in\mbox{[}3\mbox{]}, double out\mbox{[}3\mbox{]})} -\/ This will calculate the transformation without calling Update. Meant for use only within other V\-T\-K classes.  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Make\-Transform ()} -\/ Make a transform of the same type. This will actually return the same transform.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkidlist}{}\section{vtk\-Id\-List}\label{vtkcommon_vtkidlist}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Id\-List is used to represent and pass data id's between objects. vtk\-Id\-List may represent any type of integer id, but usually represents point and cell ids.

To create an instance of class vtk\-Id\-List, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkIdList
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Id\-List has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Id\-List class. 
\begin{DoxyItemize}
\item {\ttfamily obj.\-Initialize ()}  
\item {\ttfamily int = obj.\-Allocate (vtk\-Id\-Type sz, int strategy)}  
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Id\-List = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Id\-List = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Ids ()} -\/ Return the number of id's in the list.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Id (vtk\-Id\-Type i)} -\/ Return the id at location i.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Ids (vtk\-Id\-Type number)} -\/ Specify the number of ids for this object to hold. Does an allocation as well as setting the number of ids.  
\item {\ttfamily obj.\-Set\-Id (vtk\-Id\-Type i, vtk\-Id\-Type vtkid)} -\/ Set the id at location i. Doesn't do range checking so it's a bit faster than Insert\-Id. Make sure you use Set\-Number\-Of\-Ids() to allocate memory prior to using Set\-Id().  
\item {\ttfamily obj.\-Insert\-Id (vtk\-Id\-Type i, vtk\-Id\-Type vtkid)} -\/ Set the id at location i. Does range checking and allocates memory as necessary.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Id (vtk\-Id\-Type vtkid)} -\/ Add the id specified to the end of the list. Range checking is performed.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Unique\-Id (vtk\-Id\-Type vtkid)} -\/ If id is not already in list, insert it and return location in list. Otherwise return just location in list.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Pointer (vtk\-Id\-Type i)} -\/ Get a pointer to a particular data index.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Write\-Pointer (vtk\-Id\-Type i, vtk\-Id\-Type number)} -\/ Get a pointer to a particular data index. Make sure data is allocated for the number of items requested. Set Max\-Id according to the number of data values requested.  
\item {\ttfamily obj.\-Reset ()} -\/ Reset to an empty state.  
\item {\ttfamily obj.\-Squeeze ()} -\/ Free any unused memory.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Id\-List ids)} -\/ Copy an id list by explicitly copying the internal array.  
\item {\ttfamily obj.\-Delete\-Id (vtk\-Id\-Type vtkid)} -\/ Delete specified id from list. Will remove all occurrences of id in list.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Is\-Id (vtk\-Id\-Type vtkid)} -\/ Return -\/1 if id specified is not contained in the list; otherwise return the position in the list.  
\item {\ttfamily obj.\-Intersect\-With (vtk\-Id\-List \&other\-Ids)} -\/ Intersect this list with another vtk\-Id\-List. Updates current list according to result of intersection operation.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkidlistcollection}{}\section{vtk\-Id\-List\-Collection}\label{vtkcommon_vtkidlistcollection}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Id\-List\-Collection is an object that creates and manipulates lists of datasets. See also vtk\-Collection and subclasses.

To create an instance of class vtk\-Id\-List\-Collection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkIdListCollection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Id\-List\-Collection has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Id\-List\-Collection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Id\-List\-Collection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Id\-List\-Collection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Item (vtk\-Id\-List ds)} -\/ Get the next dataset in the list.  
\item {\ttfamily vtk\-Id\-List = obj.\-Get\-Next\-Item ()} -\/ Get the next dataset in the list.  
\item {\ttfamily vtk\-Id\-List = obj.\-Get\-Item (int i)} -\/ Get the ith dataset in the list.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkidtypearray}{}\section{vtk\-Id\-Type\-Array}\label{vtkcommon_vtkidtypearray}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Id\-Type\-Array is an array of values of type vtk\-Id\-Type. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Id\-Type\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkIdTypeArray
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Id\-Type\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Id\-Type\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Id\-Type\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Id\-Type\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()} -\/ Copy the tuple value into a user-\/provided array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Value (vtk\-Id\-Type id)} -\/ Set the data at a particular index. Does not do range checking. Make sure you use the method Set\-Number\-Of\-Values() before inserting data.  
\item {\ttfamily obj.\-Set\-Value (vtk\-Id\-Type id, vtk\-Id\-Type value)} -\/ Specify the number of values for this object to hold. Does an allocation as well as setting the Max\-Id ivar. Used in conjunction with Set\-Value() method for fast insertion.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Values (vtk\-Id\-Type number)} -\/ Insert data at a specified position in the array.  
\item {\ttfamily obj.\-Insert\-Value (vtk\-Id\-Type id, vtk\-Id\-Type f)} -\/ Insert data at the end of the array. Return its location in the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Value (vtk\-Id\-Type f)} -\/ Get the address of a particular data index. Make sure data is allocated for the number of items requested. Set Max\-Id according to the number of data values requested.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Write\-Pointer (vtk\-Id\-Type id, vtk\-Id\-Type number)} -\/ Get the address of a particular data index. Performs no checks to verify that the memory has been allocated etc.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Pointer (vtk\-Id\-Type id)} -\/ This method lets the user specify data to be held by the array. The array argument is a pointer to the data. size is the size of the array supplied by the user. Set save to 1 to keep the class from deleting the array when it cleans up or reallocates memory. The class uses the actual array provided; it does not copy the data from the suppled array.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkimplicitfunction}{}\section{vtk\-Implicit\-Function}\label{vtkcommon_vtkimplicitfunction}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Implicit\-Function specifies an abstract interface for implicit functions. Implicit functions are real valued functions defined in 3\-D space, w = F(x,y,z). Two primitive operations are required\-: the ability to evaluate the function, and the function gradient at a given point. The implicit function divides space into three regions\-: on the surface (F(x,y,z)=w), outside of the surface (F(x,y,z)$>$c), and inside the surface (F(x,y,z)$<$c). (When c is zero, positive values are outside, negative values are inside, and zero is on the surface. Note also that the function gradient points from inside to outside.)

Implicit functions are very powerful. It is possible to represent almost any type of geometry with the level sets w = const, especially if you use boolean combinations of implicit functions (see vtk\-Implicit\-Boolean).

vtk\-Implicit\-Function provides a mechanism to transform the implicit function(s) via a vtk\-Abstract\-Transform. This capability can be used to translate, orient, scale, or warp implicit functions. For example, a sphere implicit function can be transformed into an oriented ellipse.

To create an instance of class vtk\-Implicit\-Function, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImplicitFunction
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Implicit\-Function has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Implicit\-Function class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Implicit\-Function = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Implicit\-Function = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Overload standard modified time function. If Transform is modified, then this object is modified as well.  
\item {\ttfamily double = obj.\-Function\-Value (double x\mbox{[}3\mbox{]})} -\/ Evaluate function at position x-\/y-\/z and return value. Point x\mbox{[}3\mbox{]} is transformed through transform (if provided).  
\item {\ttfamily double = obj.\-Function\-Value (double x, double y, double z)} -\/ Evaluate function at position x-\/y-\/z and return value. Point x\mbox{[}3\mbox{]} is transformed through transform (if provided).  
\item {\ttfamily obj.\-Function\-Gradient (double x\mbox{[}3\mbox{]}, double g\mbox{[}3\mbox{]})} -\/ Evaluate function gradient at position x-\/y-\/z and pass back vector. Point x\mbox{[}3\mbox{]} is transformed through transform (if provided).  
\item {\ttfamily double = obj.\-Function\-Gradient (double x\mbox{[}3\mbox{]})} -\/ Evaluate function gradient at position x-\/y-\/z and pass back vector. Point x\mbox{[}3\mbox{]} is transformed through transform (if provided).  
\item {\ttfamily double = obj.\-Function\-Gradient (double x, double y, double z)} -\/ Evaluate function gradient at position x-\/y-\/z and pass back vector. Point x\mbox{[}3\mbox{]} is transformed through transform (if provided).  
\item {\ttfamily obj.\-Set\-Transform (vtk\-Abstract\-Transform )} -\/ Set/\-Get a transformation to apply to input points before executing the implicit function.  
\item {\ttfamily obj.\-Set\-Transform (double elements\mbox{[}16\mbox{]})} -\/ Set/\-Get a transformation to apply to input points before executing the implicit function.  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Get\-Transform ()} -\/ Set/\-Get a transformation to apply to input points before executing the implicit function.  
\item {\ttfamily double = obj.\-Evaluate\-Function (double x\mbox{[}3\mbox{]})} -\/ Evaluate function at position x-\/y-\/z and return value. You should generally not call this method directly, you should use Function\-Value() instead. This method must be implemented by any derived class.  
\item {\ttfamily double = obj.\-Evaluate\-Function (double x, double y, double z)} -\/ Evaluate function at position x-\/y-\/z and return value. You should generally not call this method directly, you should use Function\-Value() instead. This method must be implemented by any derived class.  
\item {\ttfamily obj.\-Evaluate\-Gradient (double x\mbox{[}3\mbox{]}, double g\mbox{[}3\mbox{]})} -\/ Evaluate function gradient at position x-\/y-\/z and pass back vector. You should generally not call this method directly, you should use Function\-Gradient() instead. This method must be implemented by any derived class.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkimplicitfunctioncollection}{}\section{vtk\-Implicit\-Function\-Collection}\label{vtkcommon_vtkimplicitfunctioncollection}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Implicit\-Function\-Collection is an object that creates and manipulates lists of objects of type vtk\-Implicit\-Function.

To create an instance of class vtk\-Implicit\-Function\-Collection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImplicitFunctionCollection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Implicit\-Function\-Collection has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Implicit\-Function\-Collection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Implicit\-Function\-Collection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Implicit\-Function\-Collection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Item (vtk\-Implicit\-Function )} -\/ Add an implicit function to the list.  
\item {\ttfamily vtk\-Implicit\-Function = obj.\-Get\-Next\-Item ()} -\/ Get the next implicit function in the list.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkinformation}{}\section{vtk\-Information}\label{vtkcommon_vtkinformation}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Information represents information and/or data for one input or one output of a vtk\-Algorithm. It maps from keys to values of several data types. Instances of this class are collected in vtk\-Information\-Vector instances and passed to vtk\-Algorithm\-::\-Process\-Request calls. The information and data referenced by the instance on a particular input or output define the request made to the vtk\-Algorithm instance.

To create an instance of class vtk\-Information, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInformation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Information has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Information class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Information = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Information = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Modified ()} -\/ Modified signature with no arguments that calls Modified on vtk\-Object superclass.  
\item {\ttfamily obj.\-Modified (vtk\-Information\-Key key)} -\/ Modified signature that takes an information key as an argument. Sets the new M\-Time and invokes a modified event with the information key as call data.  
\item {\ttfamily obj.\-Clear ()} -\/ Clear all information entries.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Keys ()} -\/ Return the number of keys in this information object (as would be returned by iterating over the keys).  
\item {\ttfamily obj.\-Copy (vtk\-Information from, int deep)} -\/ Copy all information entries from the given vtk\-Information instance. Any previously existing entries are removed. If deep==1, a deep copy of the information structure is performed (new instances of any contained vtk\-Information and vtk\-Information\-Vector objects are created).  
\item {\ttfamily obj.\-Copy\-Entry (vtk\-Information from, vtk\-Information\-Key key, int deep)} -\/ Copy the key/value pair associated with the given key in the given information object. If deep=1, a deep copy of the information structure is performed (new instances of any contained vtk\-Information and vtk\-Information\-Vector objects are created).  
\item {\ttfamily obj.\-Copy\-Entry (vtk\-Information from, vtk\-Information\-Data\-Object\-Key key, int deep)} -\/ Copy the key/value pair associated with the given key in the given information object. If deep=1, a deep copy of the information structure is performed (new instances of any contained vtk\-Information and vtk\-Information\-Vector objects are created).  
\item {\ttfamily obj.\-Copy\-Entry (vtk\-Information from, vtk\-Information\-Double\-Vector\-Key key, int deep)} -\/ Copy the key/value pair associated with the given key in the given information object. If deep=1, a deep copy of the information structure is performed (new instances of any contained vtk\-Information and vtk\-Information\-Vector objects are created).  
\item {\ttfamily obj.\-Copy\-Entry (vtk\-Information from, vtk\-Information\-Information\-Key key, int deep)} -\/ Copy the key/value pair associated with the given key in the given information object. If deep=1, a deep copy of the information structure is performed (new instances of any contained vtk\-Information and vtk\-Information\-Vector objects are created).  
\item {\ttfamily obj.\-Copy\-Entry (vtk\-Information from, vtk\-Information\-Information\-Vector\-Key key, int deep)} -\/ Copy the key/value pair associated with the given key in the given information object. If deep=1, a deep copy of the information structure is performed (new instances of any contained vtk\-Information and vtk\-Information\-Vector objects are created).  
\item {\ttfamily obj.\-Copy\-Entry (vtk\-Information from, vtk\-Information\-Integer\-Key key, int deep)} -\/ Copy the key/value pair associated with the given key in the given information object. If deep=1, a deep copy of the information structure is performed (new instances of any contained vtk\-Information and vtk\-Information\-Vector objects are created).  
\item {\ttfamily obj.\-Copy\-Entry (vtk\-Information from, vtk\-Information\-Integer\-Vector\-Key key, int deep)} -\/ Copy the key/value pair associated with the given key in the given information object. If deep=1, a deep copy of the information structure is performed (new instances of any contained vtk\-Information and vtk\-Information\-Vector objects are created).  
\item {\ttfamily obj.\-Copy\-Entry (vtk\-Information from, vtk\-Information\-Request\-Key key, int deep)} -\/ Copy the key/value pair associated with the given key in the given information object. If deep=1, a deep copy of the information structure is performed (new instances of any contained vtk\-Information and vtk\-Information\-Vector objects are created).  
\item {\ttfamily obj.\-Copy\-Entry (vtk\-Information from, vtk\-Information\-String\-Key key, int deep)} -\/ Copy the key/value pair associated with the given key in the given information object. If deep=1, a deep copy of the information structure is performed (new instances of any contained vtk\-Information and vtk\-Information\-Vector objects are created).  
\item {\ttfamily obj.\-Copy\-Entry (vtk\-Information from, vtk\-Information\-String\-Vector\-Key key, int deep)} -\/ Copy the key/value pair associated with the given key in the given information object. If deep=1, a deep copy of the information structure is performed (new instances of any contained vtk\-Information and vtk\-Information\-Vector objects are created).  
\item {\ttfamily obj.\-Copy\-Entry (vtk\-Information from, vtk\-Information\-Unsigned\-Long\-Key key, int deep)} -\/ Copy the key/value pair associated with the given key in the given information object. If deep=1, a deep copy of the information structure is performed (new instances of any contained vtk\-Information and vtk\-Information\-Vector objects are created).  
\item {\ttfamily obj.\-Copy\-Entries (vtk\-Information from, vtk\-Information\-Key\-Vector\-Key key, int deep)} -\/ Use the given key to lookup a list of other keys in the given information object. The key/value pairs associated with these other keys will be copied. If deep==1, a deep copy of the information structure is performed.  
\item {\ttfamily int = obj.\-Has (vtk\-Information\-Key key)} -\/ Check whether the given key appears in this information object.  
\item {\ttfamily obj.\-Remove (vtk\-Information\-Key key)} -\/ Remove the given key and its data from this information object.  
\item {\ttfamily obj.\-Set (vtk\-Information\-Request\-Key key)} -\/ Get/\-Set a request-\/valued entry.  
\item {\ttfamily obj.\-Remove (vtk\-Information\-Request\-Key key)} -\/ Get/\-Set a request-\/valued entry.  
\item {\ttfamily int = obj.\-Has (vtk\-Information\-Request\-Key key)} -\/ Get/\-Set a request-\/valued entry.  
\item {\ttfamily obj.\-Set (vtk\-Information\-Integer\-Key key, int value)} -\/ Get/\-Set an integer-\/valued entry.  
\item {\ttfamily int = obj.\-Get (vtk\-Information\-Integer\-Key key)} -\/ Get/\-Set an integer-\/valued entry.  
\item {\ttfamily obj.\-Remove (vtk\-Information\-Integer\-Key key)} -\/ Get/\-Set an integer-\/valued entry.  
\item {\ttfamily int = obj.\-Has (vtk\-Information\-Integer\-Key key)} -\/ Get/\-Set an integer-\/valued entry.  
\item {\ttfamily obj.\-Set (vtk\-Information\-Id\-Type\-Key key, vtk\-Id\-Type value)} -\/ Get/\-Set a vtk\-Id\-Type-\/valued entry.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get (vtk\-Information\-Id\-Type\-Key key)} -\/ Get/\-Set a vtk\-Id\-Type-\/valued entry.  
\item {\ttfamily obj.\-Remove (vtk\-Information\-Id\-Type\-Key key)} -\/ Get/\-Set a vtk\-Id\-Type-\/valued entry.  
\item {\ttfamily int = obj.\-Has (vtk\-Information\-Id\-Type\-Key key)} -\/ Get/\-Set a vtk\-Id\-Type-\/valued entry.  
\item {\ttfamily obj.\-Set (vtk\-Information\-Double\-Key key, double value)} -\/ Get/\-Set an double-\/valued entry.  
\item {\ttfamily double = obj.\-Get (vtk\-Information\-Double\-Key key)} -\/ Get/\-Set an double-\/valued entry.  
\item {\ttfamily obj.\-Remove (vtk\-Information\-Double\-Key key)} -\/ Get/\-Set an double-\/valued entry.  
\item {\ttfamily int = obj.\-Has (vtk\-Information\-Double\-Key key)} -\/ Get/\-Set an double-\/valued entry.  
\item {\ttfamily obj.\-Append (vtk\-Information\-Integer\-Vector\-Key key, int value)} -\/ Get/\-Set an integer-\/vector-\/valued entry.  
\item {\ttfamily obj.\-Set (vtk\-Information\-Integer\-Vector\-Key key, int value, int length)} -\/ Get/\-Set an integer-\/vector-\/valued entry.  
\item {\ttfamily obj.\-Set (vtk\-Information\-Integer\-Vector\-Key key, int value1, int value2, int value3)} -\/ Get/\-Set an integer-\/vector-\/valued entry.  
\item {\ttfamily obj.\-Set (vtk\-Information\-Integer\-Vector\-Key key, int value1, int value2, int value3, int value4, int value5, int value6)} -\/ Get/\-Set an integer-\/vector-\/valued entry.  
\item {\ttfamily int = obj.\-Get (vtk\-Information\-Integer\-Vector\-Key key, int idx)} -\/ Get/\-Set an integer-\/vector-\/valued entry.  
\item {\ttfamily obj.\-Get (vtk\-Information\-Integer\-Vector\-Key key, int value)} -\/ Get/\-Set an integer-\/vector-\/valued entry.  
\item {\ttfamily int = obj.\-Length (vtk\-Information\-Integer\-Vector\-Key key)} -\/ Get/\-Set an integer-\/vector-\/valued entry.  
\item {\ttfamily obj.\-Remove (vtk\-Information\-Integer\-Vector\-Key key)} -\/ Get/\-Set an integer-\/vector-\/valued entry.  
\item {\ttfamily int = obj.\-Has (vtk\-Information\-Integer\-Vector\-Key key)} -\/ Get/\-Set an integer-\/vector-\/valued entry.  
\item {\ttfamily obj.\-Append (vtk\-Information\-String\-Vector\-Key key, string value)} -\/ Get/\-Set a string-\/vector-\/valued entry.  
\item {\ttfamily obj.\-Set (vtk\-Information\-String\-Vector\-Key key, string value, int idx)} -\/ Get/\-Set a string-\/vector-\/valued entry.  
\item {\ttfamily string = obj.\-Get (vtk\-Information\-String\-Vector\-Key key, int idx)} -\/ Get/\-Set a string-\/vector-\/valued entry.  
\item {\ttfamily int = obj.\-Length (vtk\-Information\-String\-Vector\-Key key)} -\/ Get/\-Set a string-\/vector-\/valued entry.  
\item {\ttfamily obj.\-Remove (vtk\-Information\-String\-Vector\-Key key)} -\/ Get/\-Set a string-\/vector-\/valued entry.  
\item {\ttfamily int = obj.\-Has (vtk\-Information\-String\-Vector\-Key key)} -\/ Get/\-Set a string-\/vector-\/valued entry.  
\item {\ttfamily obj.\-Set (vtk\-Information\-Integer\-Pointer\-Key key, int value, int length)} -\/ Get/\-Set an integer-\/pointer-\/valued entry.  
\item {\ttfamily obj.\-Get (vtk\-Information\-Integer\-Pointer\-Key key, int value)} -\/ Get/\-Set an integer-\/pointer-\/valued entry.  
\item {\ttfamily int = obj.\-Length (vtk\-Information\-Integer\-Pointer\-Key key)} -\/ Get/\-Set an integer-\/pointer-\/valued entry.  
\item {\ttfamily obj.\-Remove (vtk\-Information\-Integer\-Pointer\-Key key)} -\/ Get/\-Set an integer-\/pointer-\/valued entry.  
\item {\ttfamily int = obj.\-Has (vtk\-Information\-Integer\-Pointer\-Key key)} -\/ Get/\-Set an integer-\/pointer-\/valued entry.  
\item {\ttfamily obj.\-Set (vtk\-Information\-Unsigned\-Long\-Key key, long value)} -\/ Get/\-Set an unsigned-\/long-\/valued entry.  
\item {\ttfamily long = obj.\-Get (vtk\-Information\-Unsigned\-Long\-Key key)} -\/ Get/\-Set an unsigned-\/long-\/valued entry.  
\item {\ttfamily obj.\-Remove (vtk\-Information\-Unsigned\-Long\-Key key)} -\/ Get/\-Set an unsigned-\/long-\/valued entry.  
\item {\ttfamily int = obj.\-Has (vtk\-Information\-Unsigned\-Long\-Key key)} -\/ Get/\-Set an unsigned-\/long-\/valued entry.  
\item {\ttfamily obj.\-Append (vtk\-Information\-Double\-Vector\-Key key, double value)} -\/ Get/\-Set an double-\/vector-\/valued entry.  
\item {\ttfamily obj.\-Set (vtk\-Information\-Double\-Vector\-Key key, double value, int length)} -\/ Get/\-Set an double-\/vector-\/valued entry.  
\item {\ttfamily obj.\-Set (vtk\-Information\-Double\-Vector\-Key key, double value1, double value2, double value3)} -\/ Get/\-Set an double-\/vector-\/valued entry.  
\item {\ttfamily obj.\-Set (vtk\-Information\-Double\-Vector\-Key key, double value1, double value2, double value3, double value4, double value5, double value6)} -\/ Get/\-Set an double-\/vector-\/valued entry.  
\item {\ttfamily double = obj.\-Get (vtk\-Information\-Double\-Vector\-Key key, int idx)} -\/ Get/\-Set an double-\/vector-\/valued entry.  
\item {\ttfamily obj.\-Get (vtk\-Information\-Double\-Vector\-Key key, double value)} -\/ Get/\-Set an double-\/vector-\/valued entry.  
\item {\ttfamily int = obj.\-Length (vtk\-Information\-Double\-Vector\-Key key)} -\/ Get/\-Set an double-\/vector-\/valued entry.  
\item {\ttfamily obj.\-Remove (vtk\-Information\-Double\-Vector\-Key key)} -\/ Get/\-Set an double-\/vector-\/valued entry.  
\item {\ttfamily int = obj.\-Has (vtk\-Information\-Double\-Vector\-Key key)} -\/ Get/\-Set an double-\/vector-\/valued entry.  
\item {\ttfamily obj.\-Append (vtk\-Information\-Key\-Vector\-Key key, vtk\-Information\-Key value)} -\/ Get/\-Set an Information\-Key-\/vector-\/valued entry.  
\item {\ttfamily obj.\-Append\-Unique (vtk\-Information\-Key\-Vector\-Key key, vtk\-Information\-Key value)} -\/ Get/\-Set an Information\-Key-\/vector-\/valued entry.  
\item {\ttfamily obj.\-Remove (vtk\-Information\-Key\-Vector\-Key key, vtk\-Information\-Key value)} -\/ Get/\-Set an Information\-Key-\/vector-\/valued entry.  
\item {\ttfamily vtk\-Information\-Key = obj.\-Get (vtk\-Information\-Key\-Vector\-Key key, int idx)} -\/ Get/\-Set an Information\-Key-\/vector-\/valued entry.  
\item {\ttfamily int = obj.\-Length (vtk\-Information\-Key\-Vector\-Key key)} -\/ Get/\-Set an Information\-Key-\/vector-\/valued entry.  
\item {\ttfamily obj.\-Remove (vtk\-Information\-Key\-Vector\-Key key)} -\/ Get/\-Set an Information\-Key-\/vector-\/valued entry.  
\item {\ttfamily int = obj.\-Has (vtk\-Information\-Key\-Vector\-Key key)} -\/ Get/\-Set an Information\-Key-\/vector-\/valued entry.  
\item {\ttfamily obj.\-Set (vtk\-Information\-String\-Key key, string )} -\/ Get/\-Set a string-\/valued entry.  
\item {\ttfamily string = obj.\-Get (vtk\-Information\-String\-Key key)} -\/ Get/\-Set a string-\/valued entry.  
\item {\ttfamily obj.\-Remove (vtk\-Information\-String\-Key key)} -\/ Get/\-Set a string-\/valued entry.  
\item {\ttfamily int = obj.\-Has (vtk\-Information\-String\-Key key)} -\/ Get/\-Set a string-\/valued entry.  
\item {\ttfamily obj.\-Set (vtk\-Information\-Information\-Key key, vtk\-Information )} -\/ Get/\-Set an entry storing another vtk\-Information instance.  
\item {\ttfamily vtk\-Information = obj.\-Get (vtk\-Information\-Information\-Key key)} -\/ Get/\-Set an entry storing another vtk\-Information instance.  
\item {\ttfamily obj.\-Remove (vtk\-Information\-Information\-Key key)} -\/ Get/\-Set an entry storing another vtk\-Information instance.  
\item {\ttfamily int = obj.\-Has (vtk\-Information\-Information\-Key key)} -\/ Get/\-Set an entry storing another vtk\-Information instance.  
\item {\ttfamily obj.\-Set (vtk\-Information\-Information\-Vector\-Key key, vtk\-Information\-Vector )} -\/ Get/\-Set an entry storing a vtk\-Information\-Vector instance.  
\item {\ttfamily vtk\-Information\-Vector = obj.\-Get (vtk\-Information\-Information\-Vector\-Key key)} -\/ Get/\-Set an entry storing a vtk\-Information\-Vector instance.  
\item {\ttfamily obj.\-Remove (vtk\-Information\-Information\-Vector\-Key key)} -\/ Get/\-Set an entry storing a vtk\-Information\-Vector instance.  
\item {\ttfamily int = obj.\-Has (vtk\-Information\-Information\-Vector\-Key key)} -\/ Get/\-Set an entry storing a vtk\-Information\-Vector instance.  
\item {\ttfamily obj.\-Set (vtk\-Information\-Object\-Base\-Key key, vtk\-Object\-Base )} -\/ Get/\-Set an entry storing a vtk\-Object\-Base instance.  
\item {\ttfamily vtk\-Object\-Base = obj.\-Get (vtk\-Information\-Object\-Base\-Key key)} -\/ Get/\-Set an entry storing a vtk\-Object\-Base instance.  
\item {\ttfamily obj.\-Remove (vtk\-Information\-Object\-Base\-Key key)} -\/ Get/\-Set an entry storing a vtk\-Object\-Base instance.  
\item {\ttfamily int = obj.\-Has (vtk\-Information\-Object\-Base\-Key key)} -\/ Get/\-Set an entry storing a vtk\-Object\-Base instance.  
\item {\ttfamily obj.\-Set (vtk\-Information\-Data\-Object\-Key key, vtk\-Data\-Object )} -\/ Get/\-Set an entry storing a vtk\-Data\-Object instance.  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get (vtk\-Information\-Data\-Object\-Key key)} -\/ Get/\-Set an entry storing a vtk\-Data\-Object instance.  
\item {\ttfamily obj.\-Remove (vtk\-Information\-Data\-Object\-Key key)} -\/ Get/\-Set an entry storing a vtk\-Data\-Object instance.  
\item {\ttfamily int = obj.\-Has (vtk\-Information\-Data\-Object\-Key key)} -\/ Get/\-Set an entry storing a vtk\-Data\-Object instance.  
\item {\ttfamily obj.\-Register (vtk\-Object\-Base o)} -\/ Initiate garbage collection when a reference is removed.  
\item {\ttfamily obj.\-Un\-Register (vtk\-Object\-Base o)} -\/ Initiate garbage collection when a reference is removed.  
\item {\ttfamily obj.\-Set\-Request (vtk\-Information\-Request\-Key request)} -\/ Get/\-Set the Request ivar  
\item {\ttfamily vtk\-Information\-Request\-Key = obj.\-Get\-Request ()} -\/ Get/\-Set the Request ivar  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkinformationdataobjectkey}{}\section{vtk\-Information\-Data\-Object\-Key}\label{vtkcommon_vtkinformationdataobjectkey}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Information\-Data\-Object\-Key is used to represent keys in vtk\-Information for values that are vtk\-Data\-Object instances.

To create an instance of class vtk\-Information\-Data\-Object\-Key, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInformationDataObjectKey
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Information\-Data\-Object\-Key has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Information\-Data\-Object\-Key class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Information\-Data\-Object\-Key = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Information\-Data\-Object\-Key = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Information\-Data\-Object\-Key = obj.(string name, string location)}  
\item {\ttfamily $\sim$vtk\-Information\-Data\-Object\-Key = obj.()}  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Information from, vtk\-Information to)} -\/ Copy the entry associated with this key from one information object to another. If there is no entry in the first information object for this key, the value is removed from the second.  
\item {\ttfamily obj.\-Report (vtk\-Information info, vtk\-Garbage\-Collector collector)} -\/ Report a reference this key has in the given information object.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkinformationdoublekey}{}\section{vtk\-Information\-Double\-Key}\label{vtkcommon_vtkinformationdoublekey}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Information\-Double\-Key is used to represent keys for double values in vtk\-Information.

To create an instance of class vtk\-Information\-Double\-Key, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInformationDoubleKey
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Information\-Double\-Key has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Information\-Double\-Key class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Information\-Double\-Key = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Information\-Double\-Key = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Information\-Double\-Key = obj.(string name, string location)}  
\item {\ttfamily $\sim$vtk\-Information\-Double\-Key = obj.()}  
\item {\ttfamily obj.\-Set (vtk\-Information info, double )} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily double = obj.\-Get (vtk\-Information info)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Information from, vtk\-Information to)} -\/ Copy the entry associated with this key from one information object to another. If there is no entry in the first information object for this key, the value is removed from the second.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkinformationdoublevectorkey}{}\section{vtk\-Information\-Double\-Vector\-Key}\label{vtkcommon_vtkinformationdoublevectorkey}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Information\-Double\-Vector\-Key is used to represent keys for double vector values in vtk\-Information.\-h

To create an instance of class vtk\-Information\-Double\-Vector\-Key, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInformationDoubleVectorKey
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Information\-Double\-Vector\-Key has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Information\-Double\-Vector\-Key class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Information\-Double\-Vector\-Key = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Information\-Double\-Vector\-Key = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Information\-Double\-Vector\-Key = obj.(string name, string location, int length)}  
\item {\ttfamily $\sim$vtk\-Information\-Double\-Vector\-Key = obj.()}  
\item {\ttfamily obj.\-Append (vtk\-Information info, double value)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily obj.\-Set (vtk\-Information info, double value, int length)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily double = obj.\-Get (vtk\-Information info, int idx)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily obj.\-Get (vtk\-Information info, double value)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily int = obj.\-Length (vtk\-Information info)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Information from, vtk\-Information to)} -\/ Copy the entry associated with this key from one information object to another. If there is no entry in the first information object for this key, the value is removed from the second.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkinformationidtypekey}{}\section{vtk\-Information\-Id\-Type\-Key}\label{vtkcommon_vtkinformationidtypekey}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Information\-Id\-Type\-Key is used to represent keys for vtk\-Id\-Type values in vtk\-Information.

To create an instance of class vtk\-Information\-Id\-Type\-Key, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInformationIdTypeKey
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Information\-Id\-Type\-Key has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Information\-Id\-Type\-Key class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Information\-Id\-Type\-Key = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Information\-Id\-Type\-Key = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Information\-Id\-Type\-Key = obj.(string name, string location)}  
\item {\ttfamily $\sim$vtk\-Information\-Id\-Type\-Key = obj.()}  
\item {\ttfamily obj.\-Set (vtk\-Information info, vtk\-Id\-Type )} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get (vtk\-Information info)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Information from, vtk\-Information to)} -\/ Copy the entry associated with this key from one information object to another. If there is no entry in the first information object for this key, the value is removed from the second.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkinformationinformationkey}{}\section{vtk\-Information\-Information\-Key}\label{vtkcommon_vtkinformationinformationkey}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Information\-Information\-Key is used to represent keys in vtk\-Information for other information objects.

To create an instance of class vtk\-Information\-Information\-Key, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInformationInformationKey
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Information\-Information\-Key has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Information\-Information\-Key class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Information\-Information\-Key = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Information\-Information\-Key = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Information\-Information\-Key = obj.(string name, string location)}  
\item {\ttfamily $\sim$vtk\-Information\-Information\-Key = obj.()}  
\item {\ttfamily obj.\-Set (vtk\-Information info, vtk\-Information )} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily vtk\-Information = obj.\-Get (vtk\-Information info)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Information from, vtk\-Information to)} -\/ Copy the entry associated with this key from one information object to another. If there is no entry in the first information object for this key, the value is removed from the second.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Information from, vtk\-Information to)} -\/ Duplicate (new instance created) the entry associated with this key from one information object to another (new instances of any contained vtk\-Information and vtk\-Information\-Vector objects are created).  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkinformationinformationvectorkey}{}\section{vtk\-Information\-Information\-Vector\-Key}\label{vtkcommon_vtkinformationinformationvectorkey}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Information\-Information\-Vector\-Key is used to represent keys in vtk\-Information for vectors of other vtk\-Information objects.

To create an instance of class vtk\-Information\-Information\-Vector\-Key, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInformationInformationVectorKey
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Information\-Information\-Vector\-Key has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Information\-Information\-Vector\-Key class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Information\-Information\-Vector\-Key = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Information\-Information\-Vector\-Key = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Information\-Information\-Vector\-Key = obj.(string name, string location)}  
\item {\ttfamily $\sim$vtk\-Information\-Information\-Vector\-Key = obj.()}  
\item {\ttfamily obj.\-Set (vtk\-Information info, vtk\-Information\-Vector )} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily vtk\-Information\-Vector = obj.\-Get (vtk\-Information info)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Information from, vtk\-Information to)} -\/ Copy the entry associated with this key from one information object to another. If there is no entry in the first information object for this key, the value is removed from the second.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Information from, vtk\-Information to)} -\/ Duplicate (new instance created) the entry associated with this key from one information object to another (new instances of any contained vtk\-Information and vtk\-Information\-Vector objects are created).  
\item {\ttfamily obj.\-Report (vtk\-Information info, vtk\-Garbage\-Collector collector)} -\/ Report a reference this key has in the given information object.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkinformationintegerkey}{}\section{vtk\-Information\-Integer\-Key}\label{vtkcommon_vtkinformationintegerkey}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Information\-Integer\-Key is used to represent keys for integer values in vtk\-Information.

To create an instance of class vtk\-Information\-Integer\-Key, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInformationIntegerKey
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Information\-Integer\-Key has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Information\-Integer\-Key class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Information\-Integer\-Key = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Information\-Integer\-Key = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Information\-Integer\-Key = obj.(string name, string location)}  
\item {\ttfamily $\sim$vtk\-Information\-Integer\-Key = obj.()}  
\item {\ttfamily obj.\-Set (vtk\-Information info, int )} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily int = obj.\-Get (vtk\-Information info)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Information from, vtk\-Information to)} -\/ Copy the entry associated with this key from one information object to another. If there is no entry in the first information object for this key, the value is removed from the second.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkinformationintegerpointerkey}{}\section{vtk\-Information\-Integer\-Pointer\-Key}\label{vtkcommon_vtkinformationintegerpointerkey}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Information\-Integer\-Pointer\-Key is used to represent keys for pointer to integer values in vtk\-Information.\-h

To create an instance of class vtk\-Information\-Integer\-Pointer\-Key, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInformationIntegerPointerKey
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Information\-Integer\-Pointer\-Key has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Information\-Integer\-Pointer\-Key class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Information\-Integer\-Pointer\-Key = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Information\-Integer\-Pointer\-Key = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Information\-Integer\-Pointer\-Key = obj.(string name, string location, int length)}  
\item {\ttfamily $\sim$vtk\-Information\-Integer\-Pointer\-Key = obj.()}  
\item {\ttfamily obj.\-Set (vtk\-Information info, int value, int length)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily obj.\-Get (vtk\-Information info, int value)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily int = obj.\-Length (vtk\-Information info)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Information from, vtk\-Information to)} -\/ Copy the entry associated with this key from one information object to another. If there is no entry in the first information object for this key, the value is removed from the second.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkinformationintegervectorkey}{}\section{vtk\-Information\-Integer\-Vector\-Key}\label{vtkcommon_vtkinformationintegervectorkey}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Information\-Integer\-Vector\-Key is used to represent keys for integer vector values in vtk\-Information.\-h

To create an instance of class vtk\-Information\-Integer\-Vector\-Key, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInformationIntegerVectorKey
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Information\-Integer\-Vector\-Key has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Information\-Integer\-Vector\-Key class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Information\-Integer\-Vector\-Key = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Information\-Integer\-Vector\-Key = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Information\-Integer\-Vector\-Key = obj.(string name, string location, int length)}  
\item {\ttfamily $\sim$vtk\-Information\-Integer\-Vector\-Key = obj.()}  
\item {\ttfamily obj.\-Append (vtk\-Information info, int value)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily obj.\-Set (vtk\-Information info, int value, int length)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily int = obj.\-Get (vtk\-Information info, int idx)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily obj.\-Get (vtk\-Information info, int value)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily int = obj.\-Length (vtk\-Information info)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Information from, vtk\-Information to)} -\/ Copy the entry associated with this key from one information object to another. If there is no entry in the first information object for this key, the value is removed from the second.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkinformationiterator}{}\section{vtk\-Information\-Iterator}\label{vtkcommon_vtkinformationiterator}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Information\-Iterator can be used to iterate over the keys of an information object. The corresponding values can then be directly obtained from the information object using the keys.

To create an instance of class vtk\-Information\-Iterator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInformationIterator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Information\-Iterator has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Information\-Iterator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Information\-Iterator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Information\-Iterator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Information (vtk\-Information )} -\/ Set/\-Get the information to iterator over.  
\item {\ttfamily vtk\-Information = obj.\-Get\-Information ()} -\/ Set/\-Get the information to iterator over.  
\item {\ttfamily obj.\-Init\-Traversal ()} -\/ Move the iterator to the beginning of the collection.  
\item {\ttfamily obj.\-Go\-To\-First\-Item ()} -\/ Move the iterator to the beginning of the collection.  
\item {\ttfamily obj.\-Go\-To\-Next\-Item ()} -\/ Move the iterator to the next item in the collection.  
\item {\ttfamily int = obj.\-Is\-Done\-With\-Traversal ()} -\/ Test whether the iterator is currently pointing to a valid item. Returns 1 for yes, 0 for no.  
\item {\ttfamily vtk\-Information\-Key = obj.\-Get\-Current\-Key ()} -\/ Get the current item. Valid only when Is\-Done\-With\-Traversal() returns 1.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkinformationkey}{}\section{vtk\-Information\-Key}\label{vtkcommon_vtkinformationkey}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Information\-Key is the superclass for all keys used to access the map represented by vtk\-Information. The vtk\-Information\-::\-Set and vtk\-Information\-::\-Get methods of vtk\-Information are accessed by information keys. A key is a pointer to an instance of a subclass of vtk\-Information\-Key. The type of the subclass determines the overload of Set/\-Get that is selected. This ensures that the type of value stored in a vtk\-Information instance corresponding to a given key matches the type expected for that key.

To create an instance of class vtk\-Information\-Key, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInformationKey
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Information\-Key has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Information\-Key class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Information\-Key = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Information\-Key = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Register (vtk\-Object\-Base )} -\/ Prevent normal vtk\-Object reference counting behavior.  
\item {\ttfamily obj.\-Un\-Register (vtk\-Object\-Base )} -\/ Prevent normal vtk\-Object reference counting behavior.  
\item {\ttfamily string = obj.\-Get\-Name ()} -\/ Get the name of the key. This is not the type of the key, but the name of the key instance.  
\item {\ttfamily string = obj.\-Get\-Location ()} -\/ Get the location of the key. This is the name of the class in which the key is defined.  
\item {\ttfamily vtk\-Information\-Key = obj.(string name, string location)} -\/ Key instances are static data that need to be created and destroyed. The constructor and destructor must be public. The name of the static instance and the class in which it is defined should be passed to the constructor. They must be string literals because the strings are not copied.  
\item {\ttfamily $\sim$vtk\-Information\-Key = obj.()} -\/ Key instances are static data that need to be created and destroyed. The constructor and destructor must be public. The name of the static instance and the class in which it is defined should be passed to the constructor. They must be string literals because the strings are not copied.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Information from, vtk\-Information to)} -\/ Copy the entry associated with this key from one information object to another. If there is no entry in the first information object for this key, the value is removed from the second.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Information from, vtk\-Information to)} -\/ Check whether this key appears in the given information object.  
\item {\ttfamily int = obj.\-Has (vtk\-Information info)} -\/ Check whether this key appears in the given information object.  
\item {\ttfamily obj.\-Remove (vtk\-Information info)} -\/ Remove this key from the given information object.  
\item {\ttfamily obj.\-Report (vtk\-Information info, vtk\-Garbage\-Collector collector)} -\/ Report a reference this key has in the given information object.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkinformationkeyvectorkey}{}\section{vtk\-Information\-Key\-Vector\-Key}\label{vtkcommon_vtkinformationkeyvectorkey}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Information\-Key\-Vector\-Key is used to represent keys for vector-\/of-\/keys values in vtk\-Information.

To create an instance of class vtk\-Information\-Key\-Vector\-Key, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInformationKeyVectorKey
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Information\-Key\-Vector\-Key has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Information\-Key\-Vector\-Key class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Information\-Key\-Vector\-Key = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Information\-Key\-Vector\-Key = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Information\-Key\-Vector\-Key = obj.(string name, string location)}  
\item {\ttfamily $\sim$vtk\-Information\-Key\-Vector\-Key = obj.()}  
\item {\ttfamily obj.\-Append (vtk\-Information info, vtk\-Information\-Key value)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily obj.\-Append\-Unique (vtk\-Information info, vtk\-Information\-Key value)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily obj.\-Remove\-Item (vtk\-Information info, vtk\-Information\-Key value)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily vtk\-Information\-Key = obj.\-Get (vtk\-Information info, int idx)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily int = obj.\-Length (vtk\-Information info)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Information from, vtk\-Information to)} -\/ Copy the entry associated with this key from one information object to another. If there is no entry in the first information object for this key, the value is removed from the second.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkinformationobjectbasekey}{}\section{vtk\-Information\-Object\-Base\-Key}\label{vtkcommon_vtkinformationobjectbasekey}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Information\-Object\-Base\-Key is used to represent keys in vtk\-Information for values that are vtk\-Object\-Base instances.

To create an instance of class vtk\-Information\-Object\-Base\-Key, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInformationObjectBaseKey
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Information\-Object\-Base\-Key has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Information\-Object\-Base\-Key class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Information\-Object\-Base\-Key = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Information\-Object\-Base\-Key = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Information\-Object\-Base\-Key = obj.(string name, string location, string required\-Class)}  
\item {\ttfamily $\sim$vtk\-Information\-Object\-Base\-Key = obj.()}  
\item {\ttfamily obj.\-Set (vtk\-Information info, vtk\-Object\-Base )} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily vtk\-Object\-Base = obj.\-Get (vtk\-Information info)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Information from, vtk\-Information to)} -\/ Copy the entry associated with this key from one information object to another. If there is no entry in the first information object for this key, the value is removed from the second.  
\item {\ttfamily obj.\-Report (vtk\-Information info, vtk\-Garbage\-Collector collector)} -\/ Report a reference this key has in the given information object.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkinformationobjectbasevectorkey}{}\section{vtk\-Information\-Object\-Base\-Vector\-Key}\label{vtkcommon_vtkinformationobjectbasevectorkey}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Information\-Object\-Base\-Vector\-Key is used to represent keys for double vector values in vtk\-Information.\-h. N\-O\-T\-E the interface in this key differs from that in other similar keys because of our internal use of smart pointers.

To create an instance of class vtk\-Information\-Object\-Base\-Vector\-Key, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInformationObjectBaseVectorKey
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Information\-Object\-Base\-Vector\-Key has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Information\-Object\-Base\-Vector\-Key class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Information\-Object\-Base\-Vector\-Key = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Information\-Object\-Base\-Vector\-Key = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Information\-Object\-Base\-Vector\-Key = obj.(string name, string location, string required\-Class)} -\/ The name of the static instance and the class in which it is defined(location) should be passed to the constructor. Providing \char`\"{}required\-Class\char`\"{} name one can insure that only objects of type \char`\"{}required\-Class\char`\"{} are stored in vectors associated with the instance of this key type created. These should be string literals as they are not coppied.  
\item {\ttfamily $\sim$vtk\-Information\-Object\-Base\-Vector\-Key = obj.()} -\/ The name of the static instance and the class in which it is defined(location) should be passed to the constructor. Providing \char`\"{}required\-Class\char`\"{} name one can insure that only objects of type \char`\"{}required\-Class\char`\"{} are stored in vectors associated with the instance of this key type created. These should be string literals as they are not coppied.


\item {\ttfamily obj.\-Clear (vtk\-Information info)} -\/ Clear the vector.  
\item {\ttfamily obj.\-Resize (vtk\-Information info, int n)} -\/ Resize (extend) the vector to hold n objects. Any new elements created will be null initialized.  
\item {\ttfamily int = obj.\-Size (vtk\-Information info)} -\/ Get the vector's length.  
\item {\ttfamily int = obj.\-Length (vtk\-Information info)} -\/ Put the value on the back of the vector, with ref counting.  
\item {\ttfamily obj.\-Append (vtk\-Information info, vtk\-Object\-Base value)} -\/ Put the value on the back of the vector, with ref counting.  
\item {\ttfamily obj.\-Set (vtk\-Information info, vtk\-Object\-Base value, int i)} -\/ Set element i of the vector to value. Resizes the vector if needed.  
\item {\ttfamily vtk\-Object\-Base = obj.\-Get (vtk\-Information info, int idx)} -\/ Get the vtk\-Object\-Base at a specific location in the vector.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Information from, vtk\-Information to)} -\/ Copy the entry associated with this key from one information object to another. If there is no entry in the first information object for this key, the value is removed from the second.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkinformationquadratureschemedefinitionvectorkey}{}\section{vtk\-Information\-Quadrature\-Scheme\-Definition\-Vector\-Key}\label{vtkcommon_vtkinformationquadratureschemedefinitionvectorkey}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Information\-Quadrature\-Scheme\-Definition\-Vector\-Key is used to represent keys for double vector values in vtk\-Information.\-h. N\-O\-T\-E the interface in this key differs from that in other similar keys because of our internal use of smart pointers.

To create an instance of class vtk\-Information\-Quadrature\-Scheme\-Definition\-Vector\-Key, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInformationQuadratureSchemeDefinitionVectorKey
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Information\-Quadrature\-Scheme\-Definition\-Vector\-Key has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Information\-Quadrature\-Scheme\-Definition\-Vector\-Key class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Information\-Quadrature\-Scheme\-Definition\-Vector\-Key = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Information\-Quadrature\-Scheme\-Definition\-Vector\-Key = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Information\-Quadrature\-Scheme\-Definition\-Vector\-Key = obj.(string name, string location)} -\/ The name of the static instance and the class in which it is defined(location) should be passed to the constructor.  
\item {\ttfamily $\sim$vtk\-Information\-Quadrature\-Scheme\-Definition\-Vector\-Key = obj.()} -\/ The name of the static instance and the class in which it is defined(location) should be passed to the constructor.


\item {\ttfamily obj.\-Clear (vtk\-Information info)} -\/ Clear the vector.  
\item {\ttfamily obj.\-Resize (vtk\-Information info, int n)} -\/ Resize (extend) the vector to hold n objects. Any new elements created will be null initialized.  
\item {\ttfamily int = obj.\-Size (vtk\-Information info)} -\/ Get the vector's length.  
\item {\ttfamily int = obj.\-Length (vtk\-Information info)} -\/ Put the value on the back of the vector, with reference counting.  
\item {\ttfamily obj.\-Append (vtk\-Information info, vtk\-Quadrature\-Scheme\-Definition value)} -\/ Put the value on the back of the vector, with reference counting.  
\item {\ttfamily obj.\-Set (vtk\-Information info, vtk\-Quadrature\-Scheme\-Definition value, int i)} -\/ Set element i of the vector to value. Resizes the vector if needed.  
\item {\ttfamily vtk\-Quadrature\-Scheme\-Definition = obj.\-Get (vtk\-Information info, int idx)} -\/ Get the vtk\-Quadrature\-Scheme\-Definition at a specific location in the vector.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Information from, vtk\-Information to)} -\/ Copy the entry associated with this key from one information object to another. If there is no entry in the first information object for this key, the value is removed from the second.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Information from, vtk\-Information to)} -\/ Copy the entry associated with this key from one information object to another. If there is no entry in the first information object for this key, the value is removed from the second.  
\item {\ttfamily int = obj.\-Save\-State (vtk\-Information info, vtk\-X\-M\-L\-Data\-Element element)} -\/ Generate an X\-M\-L representation of the object. Each key/value pair will be nested in the resulting X\-M\-L hierarchy. The element passed in is assumed to be empty.  
\item {\ttfamily int = obj.\-Restore\-State (vtk\-Information info, vtk\-X\-M\-L\-Data\-Element element)} -\/ Load key/value pairs from an X\-M\-L state representation created with Save\-State. Duplicate keys will generate a fatal error.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkinformationrequestkey}{}\section{vtk\-Information\-Request\-Key}\label{vtkcommon_vtkinformationrequestkey}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Information\-Request\-Key is used to represent keys for pointer to pointer values in vtk\-Information.\-h

To create an instance of class vtk\-Information\-Request\-Key, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInformationRequestKey
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Information\-Request\-Key has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Information\-Request\-Key class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Information\-Request\-Key = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Information\-Request\-Key = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Information\-Request\-Key = obj.(string name, string location)}  
\item {\ttfamily $\sim$vtk\-Information\-Request\-Key = obj.()}  
\item {\ttfamily obj.\-Set (vtk\-Information info)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily obj.\-Remove (vtk\-Information info)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily int = obj.\-Has (vtk\-Information info)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Information from, vtk\-Information to)} -\/ Copy the entry associated with this key from one information object to another. If there is no entry in the first information object for this key, the value is removed from the second.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkinformationstringkey}{}\section{vtk\-Information\-String\-Key}\label{vtkcommon_vtkinformationstringkey}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Information\-String\-Key is used to represent keys for string values in vtk\-Information.

To create an instance of class vtk\-Information\-String\-Key, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInformationStringKey
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Information\-String\-Key has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Information\-String\-Key class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Information\-String\-Key = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Information\-String\-Key = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Information\-String\-Key = obj.(string name, string location)}  
\item {\ttfamily $\sim$vtk\-Information\-String\-Key = obj.()}  
\item {\ttfamily obj.\-Set (vtk\-Information info, string )} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily string = obj.\-Get (vtk\-Information info)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Information from, vtk\-Information to)} -\/ Copy the entry associated with this key from one information object to another. If there is no entry in the first information object for this key, the value is removed from the second.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkinformationstringvectorkey}{}\section{vtk\-Information\-String\-Vector\-Key}\label{vtkcommon_vtkinformationstringvectorkey}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Information\-String\-Vector\-Key is used to represent keys for String vector values in vtk\-Information.\-h

To create an instance of class vtk\-Information\-String\-Vector\-Key, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInformationStringVectorKey
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Information\-String\-Vector\-Key has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Information\-String\-Vector\-Key class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Information\-String\-Vector\-Key = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Information\-String\-Vector\-Key = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Information\-String\-Vector\-Key = obj.(string name, string location, int length)}  
\item {\ttfamily $\sim$vtk\-Information\-String\-Vector\-Key = obj.()}  
\item {\ttfamily obj.\-Append (vtk\-Information info, string value)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily obj.\-Set (vtk\-Information info, string value, int idx)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily string = obj.\-Get (vtk\-Information info, int idx)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily int = obj.\-Length (vtk\-Information info)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Information from, vtk\-Information to)} -\/ Copy the entry associated with this key from one information object to another. If there is no entry in the first information object for this key, the value is removed from the second.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkinformationunsignedlongkey}{}\section{vtk\-Information\-Unsigned\-Long\-Key}\label{vtkcommon_vtkinformationunsignedlongkey}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Information\-Unsigned\-Long\-Key is used to represent keys for unsigned long values in vtk\-Information.

To create an instance of class vtk\-Information\-Unsigned\-Long\-Key, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInformationUnsignedLongKey
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Information\-Unsigned\-Long\-Key has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Information\-Unsigned\-Long\-Key class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Information\-Unsigned\-Long\-Key = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Information\-Unsigned\-Long\-Key = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Information\-Unsigned\-Long\-Key = obj.(string name, string location)}  
\item {\ttfamily $\sim$vtk\-Information\-Unsigned\-Long\-Key = obj.()}  
\item {\ttfamily obj.\-Set (vtk\-Information info, long )} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily long = obj.\-Get (vtk\-Information info)} -\/ Get/\-Set the value associated with this key in the given information object.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Information from, vtk\-Information to)} -\/ Copy the entry associated with this key from one information object to another. If there is no entry in the first information object for this key, the value is removed from the second.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkinformationvector}{}\section{vtk\-Information\-Vector}\label{vtkcommon_vtkinformationvector}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
To create an instance of class vtk\-Information\-Vector, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInformationVector
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Information\-Vector has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Information\-Vector class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Information\-Vector = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Information\-Vector = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Information\-Objects ()} -\/ Get/\-Set the number of information objects in the vector. Setting the number to larger than the current number will create empty vtk\-Information instances. Setting the number to smaller than the current number will remove entries from higher indices.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Information\-Objects (int n)} -\/ Get/\-Set the number of information objects in the vector. Setting the number to larger than the current number will create empty vtk\-Information instances. Setting the number to smaller than the current number will remove entries from higher indices.  
\item {\ttfamily obj.\-Set\-Information\-Object (int index, vtk\-Information info)} -\/ Get/\-Set the vtk\-Information instance stored at the given index in the vector. The vector will automatically expand to include the index given if necessary. Missing entries in-\/between will be filled with empty vtk\-Information instances.  
\item {\ttfamily vtk\-Information = obj.\-Get\-Information\-Object (int index)} -\/ Get/\-Set the vtk\-Information instance stored at the given index in the vector. The vector will automatically expand to include the index given if necessary. Missing entries in-\/between will be filled with empty vtk\-Information instances.  
\item {\ttfamily obj.\-Append (vtk\-Information info)} -\/ Append/\-Remove an information object.  
\item {\ttfamily obj.\-Remove (vtk\-Information info)} -\/ Append/\-Remove an information object.  
\item {\ttfamily obj.\-Register (vtk\-Object\-Base o)} -\/ Initiate garbage collection when a reference is removed.  
\item {\ttfamily obj.\-Un\-Register (vtk\-Object\-Base o)} -\/ Initiate garbage collection when a reference is removed.  
\item {\ttfamily obj.\-Copy (vtk\-Information\-Vector from, int deep)} -\/ Copy all information entries from the given vtk\-Information instance. Any previously existing entries are removed. If deep==1, a deep copy of the information structure is performed (new instances of any contained vtk\-Information and vtk\-Information\-Vector objects are created).  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkinitialvalueproblemsolver}{}\section{vtk\-Initial\-Value\-Problem\-Solver}\label{vtkcommon_vtkinitialvalueproblemsolver}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Given a vtk\-Function\-Set which returns d\-F\-\_\-i(x\-\_\-j, t)/dt given x\-\_\-j and t, vtk\-Initial\-Value\-Problem\-Solver computes the value of F\-\_\-i at t+deltat.

To create an instance of class vtk\-Initial\-Value\-Problem\-Solver, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInitialValueProblemSolver
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Initial\-Value\-Problem\-Solver has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Initial\-Value\-Problem\-Solver class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Initial\-Value\-Problem\-Solver = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Initial\-Value\-Problem\-Solver = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Function\-Set (vtk\-Function\-Set functionset)} -\/ Set / get the dataset used for the implicit function evaluation.  
\item {\ttfamily vtk\-Function\-Set = obj.\-Get\-Function\-Set ()} -\/ Set / get the dataset used for the implicit function evaluation.  
\item {\ttfamily int = obj.\-Is\-Adaptive ()}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkinstantiator}{}\section{vtk\-Instantiator}\label{vtkcommon_vtkinstantiator}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Instantiator provides an interface to create an instance of any V\-T\-K class from its name. Instances are created through registered pointers to functions returning the objects. New classes can also be registered with the creator. V\-T\-K libraries automatically register their classes with the creator when they are loaded. Instances are created using the static New() method, so the normal vtk\-Object\-Factory mechanism is still invoked.

When using this class from language wrappers (Tcl, Python, or Java), the vtk\-Instantiator should be able to create any class from any kit that has been loaded.

In C++ code, one should include the header for each kit from which one wishes to create instances through vtk\-Instantiator. This is necessary to ensure proper linking when building static libraries. Be careful, though, because including each kit's header means every class from that kit will be linked into your executable whether or not the class is used. The headers are\-:

vtk\-Common -\/ vtk\-Common\-Instantiator.\-h vtk\-Filtering -\/ vtk\-Filtering\-Instantiator.\-h vtk\-I\-O -\/ vtk\-I\-O\-Instantiator.\-h vtk\-Imaging -\/ vtk\-Imaging\-Instantiator.\-h vtk\-Graphics -\/ vtk\-Graphics\-Instantiator.\-h vtk\-Rendering -\/ vtk\-Rendering\-Instantiator.\-h vtk\-Volume\-Rendering -\/ vtk\-Volume\-Rendering\-Instantiator.\-h vtk\-Hybrid -\/ vtk\-Hybrid\-Instantiator.\-h vtk\-Parallel -\/ vtk\-Parallel\-Instantiator.\-h

The V\-T\-K\-\_\-\-M\-A\-K\-E\-\_\-\-I\-N\-S\-T\-A\-N\-T\-I\-A\-T\-O\-R() command in C\-Make is used to automatically generate the creator registration for each V\-T\-K library. It can also be used to create registration code for V\-T\-K-\/style user libraries that are linked to vtk\-Common. After using this command to register classes from a new library, the generated header must be included.

To create an instance of class vtk\-Instantiator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInstantiator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Instantiator has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Instantiator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Instantiator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Instantiator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkintarray}{}\section{vtk\-Int\-Array}\label{vtkcommon_vtkintarray}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Int\-Array is an array of values of type int. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Int\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkIntArray
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Int\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Int\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Int\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Int\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()} -\/ Copy the tuple value into a user-\/provided array.  
\item {\ttfamily obj.\-Get\-Tuple\-Value (vtk\-Id\-Type i, int tuple)} -\/ Set the tuple value at the ith location in the array.  
\item {\ttfamily obj.\-Set\-Tuple\-Value (vtk\-Id\-Type i, int tuple)} -\/ Insert (memory allocation performed) the tuple into the ith location in the array.  
\item {\ttfamily obj.\-Insert\-Tuple\-Value (vtk\-Id\-Type i, int tuple)} -\/ Insert (memory allocation performed) the tuple onto the end of the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Tuple\-Value (int tuple)} -\/ Get the data at a particular index.  
\item {\ttfamily int = obj.\-Get\-Value (vtk\-Id\-Type id)} -\/ Set the data at a particular index. Does not do range checking. Make sure you use the method Set\-Number\-Of\-Values() before inserting data.  
\item {\ttfamily obj.\-Set\-Value (vtk\-Id\-Type id, int value)} -\/ Specify the number of values for this object to hold. Does an allocation as well as setting the Max\-Id ivar. Used in conjunction with Set\-Value() method for fast insertion.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Values (vtk\-Id\-Type number)} -\/ Insert data at a specified position in the array.  
\item {\ttfamily obj.\-Insert\-Value (vtk\-Id\-Type id, int f)} -\/ Insert data at the end of the array. Return its location in the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Value (int f)} -\/ Get the address of a particular data index. Make sure data is allocated for the number of items requested. Set Max\-Id according to the number of data values requested.  
\item {\ttfamily obj.\-Set\-Array (int array, vtk\-Id\-Type size, int save)} -\/ This method lets the user specify data to be held by the array. The array argument is a pointer to the data. size is the size of the array supplied by the user. Set save to 1 to keep the class from deleting the array when it cleans up or reallocates memory. The class uses the actual array provided; it does not copy the data from the suppled array.  
\item {\ttfamily obj.\-Set\-Array (int array, vtk\-Id\-Type size, int save, int delete\-Method)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtklineartransform}{}\section{vtk\-Linear\-Transform}\label{vtkcommon_vtklineartransform}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Linear\-Transform provides a generic interface for linear (affine or 12 degree-\/of-\/freedom) geometric transformations.

To create an instance of class vtk\-Linear\-Transform, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLinearTransform
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Linear\-Transform has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Linear\-Transform class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Linear\-Transform = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Linear\-Transform = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Transform\-Normal (float in\mbox{[}3\mbox{]}, float out\mbox{[}3\mbox{]})} -\/ Apply the transformation to a normal. You can use the same array to store both the input and output.  
\item {\ttfamily obj.\-Transform\-Normal (double in\mbox{[}3\mbox{]}, double out\mbox{[}3\mbox{]})} -\/ Apply the transformation to a double-\/precision normal. You can use the same array to store both the input and output.  
\item {\ttfamily double = obj.\-Transform\-Normal (double x, double y, double z)} -\/ Synonymous with Transform\-Double\-Normal(x,y,z). Use this if you are programming in python, tcl or Java.  
\item {\ttfamily double = obj.\-Transform\-Normal (double normal\mbox{[}3\mbox{]})} -\/ Synonymous with Transform\-Double\-Normal(x,y,z). Use this if you are programming in python, tcl or Java.  
\item {\ttfamily float = obj.\-Transform\-Float\-Normal (float x, float y, float z)} -\/ Apply the transformation to an (x,y,z) normal. Use this if you are programming in python, tcl or Java.  
\item {\ttfamily float = obj.\-Transform\-Float\-Normal (float normal\mbox{[}3\mbox{]})} -\/ Apply the transformation to an (x,y,z) normal. Use this if you are programming in python, tcl or Java.  
\item {\ttfamily double = obj.\-Transform\-Double\-Normal (double x, double y, double z)} -\/ Apply the transformation to a double-\/precision (x,y,z) normal. Use this if you are programming in python, tcl or Java.  
\item {\ttfamily double = obj.\-Transform\-Double\-Normal (double normal\mbox{[}3\mbox{]})} -\/ Apply the transformation to a double-\/precision (x,y,z) normal. Use this if you are programming in python, tcl or Java.  
\item {\ttfamily double = obj.\-Transform\-Vector (double x, double y, double z)} -\/ Synonymous with Transform\-Double\-Vector(x,y,z). Use this if you are programming in python, tcl or Java.  
\item {\ttfamily double = obj.\-Transform\-Vector (double normal\mbox{[}3\mbox{]})} -\/ Synonymous with Transform\-Double\-Vector(x,y,z). Use this if you are programming in python, tcl or Java.  
\item {\ttfamily obj.\-Transform\-Vector (float in\mbox{[}3\mbox{]}, float out\mbox{[}3\mbox{]})} -\/ Apply the transformation to a vector. You can use the same array to store both the input and output.  
\item {\ttfamily obj.\-Transform\-Vector (double in\mbox{[}3\mbox{]}, double out\mbox{[}3\mbox{]})} -\/ Apply the transformation to a double-\/precision vector. You can use the same array to store both the input and output.  
\item {\ttfamily float = obj.\-Transform\-Float\-Vector (float x, float y, float z)} -\/ Apply the transformation to an (x,y,z) vector. Use this if you are programming in python, tcl or Java.  
\item {\ttfamily float = obj.\-Transform\-Float\-Vector (float vec\mbox{[}3\mbox{]})} -\/ Apply the transformation to an (x,y,z) vector. Use this if you are programming in python, tcl or Java.  
\item {\ttfamily double = obj.\-Transform\-Double\-Vector (double x, double y, double z)} -\/ Apply the transformation to a double-\/precision (x,y,z) vector. Use this if you are programming in python, tcl or Java.  
\item {\ttfamily double = obj.\-Transform\-Double\-Vector (double vec\mbox{[}3\mbox{]})} -\/ Apply the transformation to a double-\/precision (x,y,z) vector. Use this if you are programming in python, tcl or Java.  
\item {\ttfamily obj.\-Transform\-Points (vtk\-Points in\-Pts, vtk\-Points out\-Pts)} -\/ Apply the transformation to a series of points, and append the results to out\-Pts.  
\item {\ttfamily obj.\-Transform\-Normals (vtk\-Data\-Array in\-Nms, vtk\-Data\-Array out\-Nms)} -\/ Apply the transformation to a series of normals, and append the results to out\-Nms.  
\item {\ttfamily obj.\-Transform\-Vectors (vtk\-Data\-Array in\-Vrs, vtk\-Data\-Array out\-Vrs)} -\/ Apply the transformation to a series of vectors, and append the results to out\-Vrs.  
\item {\ttfamily obj.\-Transform\-Points\-Normals\-Vectors (vtk\-Points in\-Pts, vtk\-Points out\-Pts, vtk\-Data\-Array in\-Nms, vtk\-Data\-Array out\-Nms, vtk\-Data\-Array in\-Vrs, vtk\-Data\-Array out\-Vrs)} -\/ Apply the transformation to a combination of points, normals and vectors.  
\item {\ttfamily vtk\-Linear\-Transform = obj.\-Get\-Linear\-Inverse ()} -\/ This will calculate the transformation without calling Update. Meant for use only within other V\-T\-K classes.  
\item {\ttfamily obj.\-Internal\-Transform\-Point (float in\mbox{[}3\mbox{]}, float out\mbox{[}3\mbox{]})} -\/ This will calculate the transformation without calling Update. Meant for use only within other V\-T\-K classes.  
\item {\ttfamily obj.\-Internal\-Transform\-Point (double in\mbox{[}3\mbox{]}, double out\mbox{[}3\mbox{]})} -\/ This will calculate the transformation without calling Update. Meant for use only within other V\-T\-K classes.  
\item {\ttfamily obj.\-Internal\-Transform\-Normal (float in\mbox{[}3\mbox{]}, float out\mbox{[}3\mbox{]})} -\/ This will calculate the transformation without calling Update. Meant for use only within other V\-T\-K classes.  
\item {\ttfamily obj.\-Internal\-Transform\-Normal (double in\mbox{[}3\mbox{]}, double out\mbox{[}3\mbox{]})} -\/ This will calculate the transformation without calling Update. Meant for use only within other V\-T\-K classes.  
\item {\ttfamily obj.\-Internal\-Transform\-Vector (float in\mbox{[}3\mbox{]}, float out\mbox{[}3\mbox{]})} -\/ This will calculate the transformation without calling Update. Meant for use only within other V\-T\-K classes.  
\item {\ttfamily obj.\-Internal\-Transform\-Vector (double in\mbox{[}3\mbox{]}, double out\mbox{[}3\mbox{]})} -\/ This will calculate the transformation without calling Update. Meant for use only within other V\-T\-K classes.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkloglookuptable}{}\section{vtk\-Log\-Lookup\-Table}\label{vtkcommon_vtkloglookuptable}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is an empty shell. Use vtk\-Lookup\-Table with Set\-Scale\-To\-Log10() instead.

To create an instance of class vtk\-Log\-Lookup\-Table, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLogLookupTable
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Log\-Lookup\-Table has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Log\-Lookup\-Table class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Log\-Lookup\-Table = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Log\-Lookup\-Table = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtklongarray}{}\section{vtk\-Long\-Array}\label{vtkcommon_vtklongarray}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Long\-Array is an array of values of type long. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Long\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLongArray
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Long\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Long\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Long\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Long\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()} -\/ Copy the tuple value into a user-\/provided array.  
\item {\ttfamily obj.\-Get\-Tuple\-Value (vtk\-Id\-Type i, long tuple)} -\/ Set the tuple value at the ith location in the array.  
\item {\ttfamily obj.\-Set\-Tuple\-Value (vtk\-Id\-Type i, long tuple)} -\/ Insert (memory allocation performed) the tuple into the ith location in the array.  
\item {\ttfamily obj.\-Insert\-Tuple\-Value (vtk\-Id\-Type i, long tuple)} -\/ Insert (memory allocation performed) the tuple onto the end of the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Tuple\-Value (long tuple)} -\/ Get the data at a particular index.  
\item {\ttfamily long = obj.\-Get\-Value (vtk\-Id\-Type id)} -\/ Set the data at a particular index. Does not do range checking. Make sure you use the method Set\-Number\-Of\-Values() before inserting data.  
\item {\ttfamily obj.\-Set\-Value (vtk\-Id\-Type id, long value)} -\/ Specify the number of values for this object to hold. Does an allocation as well as setting the Max\-Id ivar. Used in conjunction with Set\-Value() method for fast insertion.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Values (vtk\-Id\-Type number)} -\/ Insert data at a specified position in the array.  
\item {\ttfamily obj.\-Insert\-Value (vtk\-Id\-Type id, long f)} -\/ Insert data at the end of the array. Return its location in the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Value (long f)} -\/ Get the address of a particular data index. Make sure data is allocated for the number of items requested. Set Max\-Id according to the number of data values requested.  
\item {\ttfamily obj.\-Set\-Array (long array, vtk\-Id\-Type size, int save)} -\/ This method lets the user specify data to be held by the array. The array argument is a pointer to the data. size is the size of the array supplied by the user. Set save to 1 to keep the class from deleting the array when it cleans up or reallocates memory. The class uses the actual array provided; it does not copy the data from the suppled array.  
\item {\ttfamily obj.\-Set\-Array (long array, vtk\-Id\-Type size, int save, int delete\-Method)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtklonglongarray}{}\section{vtk\-Long\-Long\-Array}\label{vtkcommon_vtklonglongarray}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Long\-Long\-Array is an array of values of type long long. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Long\-Long\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLongLongArray
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Long\-Long\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Long\-Long\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Long\-Long\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Long\-Long\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()} -\/ Copy the tuple value into a user-\/provided array.  
\item {\ttfamily long = obj.\-long Get\-Value (vtk\-Id\-Type id)} -\/ Set the data at a particular index. Does not do range checking. Make sure you use the method Set\-Number\-Of\-Values() before inserting data.  
\item {\ttfamily obj.\-Set\-Value (vtk\-Id\-Type id, long long value)} -\/ Specify the number of values for this object to hold. Does an allocation as well as setting the Max\-Id ivar. Used in conjunction with Set\-Value() method for fast insertion.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Values (vtk\-Id\-Type number)} -\/ Insert data at a specified position in the array.  
\item {\ttfamily obj.\-Insert\-Value (vtk\-Id\-Type id, long long f)} -\/ Insert data at the end of the array. Return its location in the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Value (long long f)} -\/ Get the address of a particular data index. Make sure data is allocated for the number of items requested. Set Max\-Id according to the number of data values requested.  
\item {\ttfamily long = obj.\-long Write\-Pointer (vtk\-Id\-Type id, vtk\-Id\-Type number)} -\/ Get the address of a particular data index. Performs no checks to verify that the memory has been allocated etc.  
\item {\ttfamily long = obj.\-long Get\-Pointer (vtk\-Id\-Type id)} -\/ This method lets the user specify data to be held by the array. The array argument is a pointer to the data. size is the size of the array supplied by the user. Set save to 1 to keep the class from deleting the array when it cleans up or reallocates memory. The class uses the actual array provided; it does not copy the data from the suppled array.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtklookuptable}{}\section{vtk\-Lookup\-Table}\label{vtkcommon_vtklookuptable}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Lookup\-Table is an object that is used by mapper objects to map scalar values into rgba (red-\/green-\/blue-\/alpha transparency) color specification, or rgba into scalar values. The color table can be created by direct insertion of color values, or by specifying hue, saturation, value, and alpha range and generating a table.

To create an instance of class vtk\-Lookup\-Table, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLookupTable
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Lookup\-Table has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Lookup\-Table class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Lookup\-Table = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Lookup\-Table = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Is\-Opaque ()} -\/ Return true if all of the values defining the mapping have an opacity equal to 1. Default implementation return true.  
\item {\ttfamily int = obj.\-Allocate (int sz, int ext)} -\/ Allocate a color table of specified size.  
\item {\ttfamily obj.\-Build ()} -\/ Generate lookup table from hue, saturation, value, alpha min/max values. Table is built from linear ramp of each value.  
\item {\ttfamily obj.\-Force\-Build ()} -\/ Force the lookup table to regenerate from hue, saturation, value, and alpha min/max values. Table is built from a linear ramp of each value. Force\-Build() is useful if a lookup table has been defined manually (using Set\-Table\-Value) and then an application decides to rebuild the lookup table using the implicit process.  
\item {\ttfamily obj.\-Set\-Ramp (int )} -\/ Set the shape of the table ramp to either linear or S-\/curve. The default is S-\/curve, which tails off gradually at either end. The equation used for the S-\/curve is y = (sin((x -\/ 1/2)$\ast$pi) + 1)/2, while the equation for the linear ramp is simply y = x. For an S-\/curve greyscale ramp, you should set Number\-Of\-Table\-Values to 402 (which is 256$\ast$pi/2) to provide room for the tails of the ramp. The equation for the S\-Q\-R\-T is y = sqrt(x).  
\item {\ttfamily obj.\-Set\-Ramp\-To\-Linear ()} -\/ Set the shape of the table ramp to either linear or S-\/curve. The default is S-\/curve, which tails off gradually at either end. The equation used for the S-\/curve is y = (sin((x -\/ 1/2)$\ast$pi) + 1)/2, while the equation for the linear ramp is simply y = x. For an S-\/curve greyscale ramp, you should set Number\-Of\-Table\-Values to 402 (which is 256$\ast$pi/2) to provide room for the tails of the ramp. The equation for the S\-Q\-R\-T is y = sqrt(x).  
\item {\ttfamily obj.\-Set\-Ramp\-To\-S\-Curve ()} -\/ Set the shape of the table ramp to either linear or S-\/curve. The default is S-\/curve, which tails off gradually at either end. The equation used for the S-\/curve is y = (sin((x -\/ 1/2)$\ast$pi) + 1)/2, while the equation for the linear ramp is simply y = x. For an S-\/curve greyscale ramp, you should set Number\-Of\-Table\-Values to 402 (which is 256$\ast$pi/2) to provide room for the tails of the ramp. The equation for the S\-Q\-R\-T is y = sqrt(x).  
\item {\ttfamily obj.\-Set\-Ramp\-To\-S\-Q\-R\-T ()} -\/ Set the shape of the table ramp to either linear or S-\/curve. The default is S-\/curve, which tails off gradually at either end. The equation used for the S-\/curve is y = (sin((x -\/ 1/2)$\ast$pi) + 1)/2, while the equation for the linear ramp is simply y = x. For an S-\/curve greyscale ramp, you should set Number\-Of\-Table\-Values to 402 (which is 256$\ast$pi/2) to provide room for the tails of the ramp. The equation for the S\-Q\-R\-T is y = sqrt(x).  
\item {\ttfamily int = obj.\-Get\-Ramp ()} -\/ Set the shape of the table ramp to either linear or S-\/curve. The default is S-\/curve, which tails off gradually at either end. The equation used for the S-\/curve is y = (sin((x -\/ 1/2)$\ast$pi) + 1)/2, while the equation for the linear ramp is simply y = x. For an S-\/curve greyscale ramp, you should set Number\-Of\-Table\-Values to 402 (which is 256$\ast$pi/2) to provide room for the tails of the ramp. The equation for the S\-Q\-R\-T is y = sqrt(x).  
\item {\ttfamily obj.\-Set\-Scale (int scale)} -\/ Set the type of scale to use, linear or logarithmic. The default is linear. If the scale is logarithmic, then the Table\-Range must not cross the value zero.  
\item {\ttfamily obj.\-Set\-Scale\-To\-Linear ()} -\/ Set the type of scale to use, linear or logarithmic. The default is linear. If the scale is logarithmic, then the Table\-Range must not cross the value zero.  
\item {\ttfamily obj.\-Set\-Scale\-To\-Log10 ()} -\/ Set the type of scale to use, linear or logarithmic. The default is linear. If the scale is logarithmic, then the Table\-Range must not cross the value zero.  
\item {\ttfamily int = obj.\-Get\-Scale ()} -\/ Set the type of scale to use, linear or logarithmic. The default is linear. If the scale is logarithmic, then the Table\-Range must not cross the value zero.  
\item {\ttfamily obj.\-Set\-Table\-Range (double r\mbox{[}2\mbox{]})} -\/ Set/\-Get the minimum/maximum scalar values for scalar mapping. Scalar values less than minimum range value are clamped to minimum range value. Scalar values greater than maximum range value are clamped to maximum range value.  
\item {\ttfamily obj.\-Set\-Table\-Range (double min, double max)} -\/ Set/\-Get the minimum/maximum scalar values for scalar mapping. Scalar values less than minimum range value are clamped to minimum range value. Scalar values greater than maximum range value are clamped to maximum range value.  
\item {\ttfamily double = obj. Get\-Table\-Range ()} -\/ Set/\-Get the minimum/maximum scalar values for scalar mapping. Scalar values less than minimum range value are clamped to minimum range value. Scalar values greater than maximum range value are clamped to maximum range value.  
\item {\ttfamily obj.\-Set\-Hue\-Range (double , double )} -\/ Set the range in hue (using automatic generation). Hue ranges between \mbox{[}0,1\mbox{]}.  
\item {\ttfamily obj.\-Set\-Hue\-Range (double a\mbox{[}2\mbox{]})} -\/ Set the range in hue (using automatic generation). Hue ranges between \mbox{[}0,1\mbox{]}.  
\item {\ttfamily double = obj. Get\-Hue\-Range ()} -\/ Set the range in hue (using automatic generation). Hue ranges between \mbox{[}0,1\mbox{]}.  
\item {\ttfamily obj.\-Set\-Saturation\-Range (double , double )} -\/ Set the range in saturation (using automatic generation). Saturation ranges between \mbox{[}0,1\mbox{]}.  
\item {\ttfamily obj.\-Set\-Saturation\-Range (double a\mbox{[}2\mbox{]})} -\/ Set the range in saturation (using automatic generation). Saturation ranges between \mbox{[}0,1\mbox{]}.  
\item {\ttfamily double = obj. Get\-Saturation\-Range ()} -\/ Set the range in saturation (using automatic generation). Saturation ranges between \mbox{[}0,1\mbox{]}.  
\item {\ttfamily obj.\-Set\-Value\-Range (double , double )} -\/ Set the range in value (using automatic generation). Value ranges between \mbox{[}0,1\mbox{]}.  
\item {\ttfamily obj.\-Set\-Value\-Range (double a\mbox{[}2\mbox{]})} -\/ Set the range in value (using automatic generation). Value ranges between \mbox{[}0,1\mbox{]}.  
\item {\ttfamily double = obj. Get\-Value\-Range ()} -\/ Set the range in value (using automatic generation). Value ranges between \mbox{[}0,1\mbox{]}.  
\item {\ttfamily obj.\-Set\-Alpha\-Range (double , double )} -\/ Set the range in alpha (using automatic generation). Alpha ranges from \mbox{[}0,1\mbox{]}.  
\item {\ttfamily obj.\-Set\-Alpha\-Range (double a\mbox{[}2\mbox{]})} -\/ Set the range in alpha (using automatic generation). Alpha ranges from \mbox{[}0,1\mbox{]}.  
\item {\ttfamily double = obj. Get\-Alpha\-Range ()} -\/ Set the range in alpha (using automatic generation). Alpha ranges from \mbox{[}0,1\mbox{]}.  
\item {\ttfamily obj.\-Get\-Color (double x, double rgb\mbox{[}3\mbox{]})} -\/ Map one value through the lookup table and return the color as an R\-G\-B array of doubles between 0 and 1.  
\item {\ttfamily double = obj.\-Get\-Opacity (double v)} -\/ Map one value through the lookup table and return the alpha value (the opacity) as a double between 0 and 1.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Index (double v)} -\/ Return the table index associated with a particular value.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Table\-Values (vtk\-Id\-Type number)} -\/ Specify the number of values (i.\-e., colors) in the lookup table.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Table\-Values ()} -\/ Specify the number of values (i.\-e., colors) in the lookup table.  
\item {\ttfamily obj.\-Set\-Table\-Value (vtk\-Id\-Type indx, double rgba\mbox{[}4\mbox{]})} -\/ Directly load color into lookup table. Use \mbox{[}0,1\mbox{]} double values for color component specification. Make sure that you've either used the Build() method or used Set\-Number\-Of\-Table\-Values() prior to using this method.  
\item {\ttfamily obj.\-Set\-Table\-Value (vtk\-Id\-Type indx, double r, double g, double b, double a)} -\/ Directly load color into lookup table. Use \mbox{[}0,1\mbox{]} double values for color component specification.  
\item {\ttfamily double = obj.\-Get\-Table\-Value (vtk\-Id\-Type id)} -\/ Return a rgba color value for the given index into the lookup table. Color components are expressed as \mbox{[}0,1\mbox{]} double values.  
\item {\ttfamily obj.\-Get\-Table\-Value (vtk\-Id\-Type id, double rgba\mbox{[}4\mbox{]})} -\/ Return a rgba color value for the given index into the lookup table. Color components are expressed as \mbox{[}0,1\mbox{]} double values.  
\item {\ttfamily double = obj.\-Get\-Range ()} -\/ Sets/\-Gets the range of scalars which will be mapped. This is a duplicate of Get/\-Set\-Table\-Range.  
\item {\ttfamily obj.\-Set\-Range (double min, double max)} -\/ Sets/\-Gets the range of scalars which will be mapped. This is a duplicate of Get/\-Set\-Table\-Range.  
\item {\ttfamily obj.\-Set\-Range (double rng\mbox{[}2\mbox{]})} -\/ Sets/\-Gets the range of scalars which will be mapped. This is a duplicate of Get/\-Set\-Table\-Range.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Colors (vtk\-Id\-Type )} -\/ Set the number of colors in the lookup table. Use Set\-Number\-Of\-Table\-Values() instead, it can be used both before and after the table has been built whereas Set\-Number\-Of\-Colors() has no effect after the table has been built.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Colors\-Min\-Value ()} -\/ Set the number of colors in the lookup table. Use Set\-Number\-Of\-Table\-Values() instead, it can be used both before and after the table has been built whereas Set\-Number\-Of\-Colors() has no effect after the table has been built.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Colors\-Max\-Value ()} -\/ Set the number of colors in the lookup table. Use Set\-Number\-Of\-Table\-Values() instead, it can be used both before and after the table has been built whereas Set\-Number\-Of\-Colors() has no effect after the table has been built.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Colors ()} -\/ Set the number of colors in the lookup table. Use Set\-Number\-Of\-Table\-Values() instead, it can be used both before and after the table has been built whereas Set\-Number\-Of\-Colors() has no effect after the table has been built.  
\item {\ttfamily obj.\-Set\-Table (vtk\-Unsigned\-Char\-Array )} -\/ Set/\-Get the internal table array that is used to map the scalars to colors. The table array is an unsigned char array with 4 components representing R\-G\-B\-A.  
\item {\ttfamily vtk\-Unsigned\-Char\-Array = obj.\-Get\-Table ()} -\/ Set/\-Get the internal table array that is used to map the scalars to colors. The table array is an unsigned char array with 4 components representing R\-G\-B\-A.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Lookup\-Table lut)} -\/ Copy the contents from another Lookup\-Table  
\item {\ttfamily int = obj.\-Using\-Log\-Scale ()}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtklookuptablewithenabling}{}\section{vtk\-Lookup\-Table\-With\-Enabling}\label{vtkcommon_vtklookuptablewithenabling}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Lookup\-Table\-With\-Enabling \char`\"{}disables\char`\"{} or \char`\"{}grays out\char`\"{} output colors based on whether the given value in Enabled\-Array is \char`\"{}0\char`\"{} or not.

To create an instance of class vtk\-Lookup\-Table\-With\-Enabling, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLookupTableWithEnabling
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Lookup\-Table\-With\-Enabling has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Lookup\-Table\-With\-Enabling class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Lookup\-Table\-With\-Enabling = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Lookup\-Table\-With\-Enabling = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Data\-Array = obj.\-Get\-Enabled\-Array ()} -\/ This must be set before Map\-Scalars() is called. Indices of this array must map directly to those in the scalars array passed to Map\-Scalars(). Values of 0 in the array indicate the color should be desaturatated.  
\item {\ttfamily obj.\-Set\-Enabled\-Array (vtk\-Data\-Array enabled\-Array)} -\/ This must be set before Map\-Scalars() is called. Indices of this array must map directly to those in the scalars array passed to Map\-Scalars(). Values of 0 in the array indicate the color should be desaturatated.  
\item {\ttfamily obj.\-Disable\-Color (char r, char g, char b, string rd, string gd, string bd)} -\/ A convenience method for taking a color and desaturating it.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkmath}{}\section{vtk\-Math}\label{vtkcommon_vtkmath}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Math provides methods to perform common math operations. These include providing constants such as Pi; conversion from degrees to radians; vector operations such as dot and cross products and vector norm; matrix determinant for 2x2 and 3x3 matrices; univariate polynomial solvers; and for random number generation (for backward compatibility only).

To create an instance of class vtk\-Math, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMath
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Math has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Math class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Math = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Math = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkmatrix3x3}{}\section{vtk\-Matrix3x3}\label{vtkcommon_vtkmatrix3x3}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Matrix3x3 is a class to represent and manipulate 3x3 matrices. Specifically, it is designed to work on 3x3 transformation matrices found in 2\-D rendering using homogeneous coordinates \mbox{[}x y w\mbox{]}.

To create an instance of class vtk\-Matrix3x3, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMatrix3x3
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Matrix3x3 has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Matrix3x3 class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Matrix3x3 = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Matrix3x3 = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Matrix3x3 source)} -\/ Non-\/static member function. Assigns {\itshape from} elements array  
\item {\ttfamily obj.\-Deep\-Copy (double Elements\mbox{[}9\mbox{]})} -\/ Set all of the elements to zero.  
\item {\ttfamily obj.\-Zero ()} -\/ Set equal to Identity matrix  
\item {\ttfamily obj.\-Identity ()} -\/ Matrix Inversion (adapted from Richard Carling in \char`\"{}\-Graphics Gems,\char`\"{} Academic Press, 1990).  
\item {\ttfamily obj.\-Invert ()} -\/ Transpose the matrix and put it into out.  
\item {\ttfamily obj.\-Transpose ()} -\/ Multiply a homogeneous coordinate by this matrix, i.\-e. out = A$\ast$in. The in\mbox{[}3\mbox{]} and out\mbox{[}3\mbox{]} can be the same array.  
\item {\ttfamily obj.\-Multiply\-Point (float in\mbox{[}3\mbox{]}, float out\mbox{[}3\mbox{]})} -\/ Multiply a homogeneous coordinate by this matrix, i.\-e. out = A$\ast$in. The in\mbox{[}3\mbox{]} and out\mbox{[}3\mbox{]} can be the same array.  
\item {\ttfamily obj.\-Multiply\-Point (double in\mbox{[}3\mbox{]}, double out\mbox{[}3\mbox{]})} -\/ Multiplies matrices a and b and stores the result in c (c=a$\ast$b).  
\item {\ttfamily obj.\-Adjoint (vtk\-Matrix3x3 in, vtk\-Matrix3x3 out)} -\/ Compute the determinant of the matrix and return it.  
\item {\ttfamily double = obj.\-Determinant ()} -\/ Sets the element i,j in the matrix.  
\item {\ttfamily obj.\-Set\-Element (int i, int j, double value)} -\/ Sets the element i,j in the matrix.  
\item {\ttfamily double = obj.\-Get\-Element (int i, int j) const}  
\item {\ttfamily bool = obj.\-Is\-Identity ()}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkmatrix4x4}{}\section{vtk\-Matrix4x4}\label{vtkcommon_vtkmatrix4x4}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Matrix4x4 is a class to represent and manipulate 4x4 matrices. Specifically, it is designed to work on 4x4 transformation matrices found in 3\-D rendering using homogeneous coordinates \mbox{[}x y z w\mbox{]}.

To create an instance of class vtk\-Matrix4x4, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMatrix4x4
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Matrix4x4 has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Matrix4x4 class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Matrix4x4 = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Matrix4x4 = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Matrix4x4 source)} -\/ Non-\/static member function. Assigns {\itshape from} elements array  
\item {\ttfamily obj.\-Deep\-Copy (double Elements\mbox{[}16\mbox{]})} -\/ Set all of the elements to zero.  
\item {\ttfamily obj.\-Zero ()} -\/ Set equal to Identity matrix  
\item {\ttfamily obj.\-Identity ()} -\/ Matrix Inversion (adapted from Richard Carling in \char`\"{}\-Graphics Gems,\char`\"{} Academic Press, 1990).  
\item {\ttfamily obj.\-Invert ()} -\/ Transpose the matrix and put it into out.  
\item {\ttfamily obj.\-Transpose ()} -\/ Multiply a homogeneous coordinate by this matrix, i.\-e. out = A$\ast$in. The in\mbox{[}4\mbox{]} and out\mbox{[}4\mbox{]} can be the same array.  
\item {\ttfamily obj.\-Multiply\-Point (float in\mbox{[}4\mbox{]}, float out\mbox{[}4\mbox{]})} -\/ Multiply a homogeneous coordinate by this matrix, i.\-e. out = A$\ast$in. The in\mbox{[}4\mbox{]} and out\mbox{[}4\mbox{]} can be the same array.  
\item {\ttfamily obj.\-Multiply\-Point (double in\mbox{[}4\mbox{]}, double out\mbox{[}4\mbox{]})} -\/ For use in Java, Python or Tcl. The default Multiply\-Point() uses a single-\/precision point.  
\item {\ttfamily float = obj.\-Multiply\-Point (float in\mbox{[}4\mbox{]})} -\/ For use in Java, Python or Tcl. The default Multiply\-Point() uses a single-\/precision point.  
\item {\ttfamily float = obj.\-Multiply\-Float\-Point (float in\mbox{[}4\mbox{]})} -\/ For use in Java, Python or Tcl. The default Multiply\-Point() uses a single-\/precision point.  
\item {\ttfamily double = obj.\-Multiply\-Double\-Point (double in\mbox{[}4\mbox{]})} -\/ Multiplies matrices a and b and stores the result in c.  
\item {\ttfamily obj.\-Adjoint (vtk\-Matrix4x4 in, vtk\-Matrix4x4 out)} -\/ Compute the determinant of the matrix and return it.  
\item {\ttfamily double = obj.\-Determinant ()} -\/ Sets the element i,j in the matrix.  
\item {\ttfamily obj.\-Set\-Element (int i, int j, double value)} -\/ Sets the element i,j in the matrix.  
\item {\ttfamily double = obj.\-Get\-Element (int i, int j) const}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkmatrixtohomogeneoustransform}{}\section{vtk\-Matrix\-To\-Homogeneous\-Transform}\label{vtkcommon_vtkmatrixtohomogeneoustransform}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is a very simple class which allows a vtk\-Matrix4x4 to be used in place of a vtk\-Homogeneous\-Transform or vtk\-Abstract\-Transform. For example, if you use it as a proxy between a matrix and vtk\-Transform\-Poly\-Data\-Filter then any modifications to the matrix will automatically be reflected in the output of the filter.

To create an instance of class vtk\-Matrix\-To\-Homogeneous\-Transform, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMatrixToHomogeneousTransform
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Matrix\-To\-Homogeneous\-Transform has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Matrix\-To\-Homogeneous\-Transform class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Matrix\-To\-Homogeneous\-Transform = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Matrix\-To\-Homogeneous\-Transform = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Input (vtk\-Matrix4x4 )}  
\item {\ttfamily vtk\-Matrix4x4 = obj.\-Get\-Input ()}  
\item {\ttfamily obj.\-Inverse ()} -\/ The input matrix is left as-\/is, but the transformation matrix is inverted.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Get the M\-Time\-: this is the bit of magic that makes everything work.  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Make\-Transform ()} -\/ Make a new transform of the same type.  
\item {\ttfamily obj.\-Set\-Matrix (vtk\-Matrix4x4 matrix)} -\/  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkmatrixtolineartransform}{}\section{vtk\-Matrix\-To\-Linear\-Transform}\label{vtkcommon_vtkmatrixtolineartransform}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is a very simple class which allows a vtk\-Matrix4x4 to be used in place of a vtk\-Linear\-Transform or vtk\-Abstract\-Transform. For example, if you use it as a proxy between a matrix and vtk\-Transform\-Poly\-Data\-Filter then any modifications to the matrix will automatically be reflected in the output of the filter.

To create an instance of class vtk\-Matrix\-To\-Linear\-Transform, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMatrixToLinearTransform
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Matrix\-To\-Linear\-Transform has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Matrix\-To\-Linear\-Transform class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Matrix\-To\-Linear\-Transform = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Matrix\-To\-Linear\-Transform = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Input (vtk\-Matrix4x4 )} -\/ Set the input matrix. Any modifications to the matrix will be reflected in the transformation.  
\item {\ttfamily vtk\-Matrix4x4 = obj.\-Get\-Input ()} -\/ Set the input matrix. Any modifications to the matrix will be reflected in the transformation.  
\item {\ttfamily obj.\-Inverse ()} -\/ The input matrix is left as-\/is, but the transformation matrix is inverted.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Get the M\-Time\-: this is the bit of magic that makes everything work.  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Make\-Transform ()} -\/ Make a new transform of the same type.  
\item {\ttfamily obj.\-Set\-Matrix (vtk\-Matrix4x4 matrix)} -\/  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkminimalstandardrandomsequence}{}\section{vtk\-Minimal\-Standard\-Random\-Sequence}\label{vtkcommon_vtkminimalstandardrandomsequence}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Minimal\-Standard\-Random\-Sequence is a sequence of statistically independent pseudo random numbers uniformly distributed between 0.\-0 and 1.\-0.

The sequence is generated by a prime modulus multiplicative linear congruential generator (P\-M\-M\-L\-C\-G) or \char`\"{}\-Lehmer generator\char`\"{} with multiplier 16807 and prime modulus 2$^\wedge$(31)-\/1. The authors calls it \char`\"{}minimal standard random number generator\char`\"{}

ref\-: \char`\"{}\-Random Number Generators\-: Good Ones are Hard to Find,\char`\"{} by Stephen K. Park and Keith W. Miller in Communications of the A\-C\-M, 31, 10 (Oct. 1988) pp. 1192-\/1201. Code is at page 1195, \char`\"{}\-Integer version 2\char`\"{}

Correctness test is described in first column, page 1195\-: A seed of 1 at step 1 should give a seed of 1043618065 at step 10001.

To create an instance of class vtk\-Minimal\-Standard\-Random\-Sequence, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMinimalStandardRandomSequence
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Minimal\-Standard\-Random\-Sequence has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Minimal\-Standard\-Random\-Sequence class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Minimal\-Standard\-Random\-Sequence = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Minimal\-Standard\-Random\-Sequence = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Seed (int value)} -\/ Set the seed of the random sequence. The following pre-\/condition is stated page 1197, second column\-: valid\-\_\-seed\-: value$>$=1 \&\& value$<$=2147483646 2147483646=(2$^\wedge$31)-\/2 This method does not have this criterium as a pre-\/condition (ie it will not fail if an incorrect seed value is passed) but the value is silently changed to fit in the valid range \mbox{[}1,2147483646\mbox{]}. 2147483646 is added to a null or negative value. 2147483647 is changed to be 1 (ie 2147483646 is substracted). Implementation note\-: it also performs 3 calls to Next() to avoid the bad property that the first random number is proportional to the seed value.  
\item {\ttfamily obj.\-Set\-Seed\-Only (int value)} -\/ Set the seed of the random sequence. There is no extra internal ajustment. Only useful for writing correctness test. The following pre-\/condition is stated page 1197, second column 2147483646=(2$^\wedge$31)-\/2 This method does not have this criterium as a pre-\/condition (ie it will not fail if an incorrect seed value is passed) but the value is silently changed to fit in the valid range \mbox{[}1,2147483646\mbox{]}. 2147483646 is added to a null or negative value. 2147483647 is changed to be 1 (ie 2147483646 is substracted).  
\item {\ttfamily int = obj.\-Get\-Seed ()} -\/ Get the seed of the random sequence. Only useful for writing correctness test.  
\item {\ttfamily double = obj.\-Get\-Value ()} -\/ Current value \begin{DoxyPostcond}{Postcondition}
unit\-\_\-range\-: result$>$=0.\-0 \&\& result$<$=1.\-0  
\end{DoxyPostcond}

\item {\ttfamily obj.\-Next ()} -\/ Move to the next number in the random sequence.  
\item {\ttfamily double = obj.\-Get\-Range\-Value (double range\-Min, double range\-Max)} -\/ Convenient method to return a value in a specific range from the range \mbox{[}0,1. There is an initial implementation that can be overridden by a subclass. There is no pre-\/condition on the range\-:
\begin{DoxyItemize}
\item it can be in increasing order\-: range\-Min$<$range\-Max
\item it can be empty\-: range\-Min=range\-Max
\item it can be in decreasing order\-: range\-Min$>$range\-Max \begin{DoxyPostcond}{Postcondition}
result\-\_\-in\-\_\-range\-: (range\-Min$<$=range\-Max \&\& result$>$=range\-Min \&\& result$<$=range\-Max) $|$$|$ (range\-Max$<$=range\-Min \&\& result$>$=range\-Max \&\& result$<$=range\-Min)  
\end{DoxyPostcond}

\end{DoxyItemize}
\end{DoxyItemize}\hypertarget{vtkcommon_vtkmultithreader}{}\section{vtk\-Multi\-Threader}\label{vtkcommon_vtkmultithreader}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Multithreader is a class that provides support for multithreaded execution using sproc() on an S\-G\-I, or pthread\-\_\-create on any platform supporting P\-O\-S\-I\-X threads. This class can be used to execute a single method on multiple threads, or to specify a method per thread.

To create an instance of class vtk\-Multi\-Threader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMultiThreader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Multi\-Threader has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Multi\-Threader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Multi\-Threader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Multi\-Threader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Number\-Of\-Threads (int )} -\/ Get/\-Set the number of threads to create. It will be clamped to the range 1 -\/ V\-T\-K\-\_\-\-M\-A\-X\-\_\-\-T\-H\-R\-E\-A\-D\-S, so the caller of this method should check that the requested number of threads was accepted.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Threads\-Min\-Value ()} -\/ Get/\-Set the number of threads to create. It will be clamped to the range 1 -\/ V\-T\-K\-\_\-\-M\-A\-X\-\_\-\-T\-H\-R\-E\-A\-D\-S, so the caller of this method should check that the requested number of threads was accepted.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Threads\-Max\-Value ()} -\/ Get/\-Set the number of threads to create. It will be clamped to the range 1 -\/ V\-T\-K\-\_\-\-M\-A\-X\-\_\-\-T\-H\-R\-E\-A\-D\-S, so the caller of this method should check that the requested number of threads was accepted.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Threads ()} -\/ Get/\-Set the number of threads to create. It will be clamped to the range 1 -\/ V\-T\-K\-\_\-\-M\-A\-X\-\_\-\-T\-H\-R\-E\-A\-D\-S, so the caller of this method should check that the requested number of threads was accepted.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkmutexlock}{}\section{vtk\-Mutex\-Lock}\label{vtkcommon_vtkmutexlock}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Mutex\-Lock allows the locking of variables which are accessed through different threads. This header file also defines vtk\-Simple\-Mutex\-Lock which is not a subclass of vtk\-Object.

To create an instance of class vtk\-Mutex\-Lock, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMutexLock
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Mutex\-Lock has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Mutex\-Lock class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Mutex\-Lock = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Mutex\-Lock = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Lock (void )} -\/ Lock the vtk\-Mutex\-Lock  
\item {\ttfamily obj.\-Unlock (void )} -\/ Unlock the vtk\-Mutex\-Lock  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkobject}{}\section{vtk\-Object}\label{vtkcommon_vtkobject}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Object is the base class for most objects in the visualization toolkit. vtk\-Object provides methods for tracking modification time, debugging, printing, and event callbacks. Most objects created within the V\-T\-K framework should be a subclass of vtk\-Object or one of its children. The few exceptions tend to be very small helper classes that usually never get instantiated or situations where multiple inheritance gets in the way. vtk\-Object also performs reference counting\-: objects that are reference counted exist as long as another object uses them. Once the last reference to a reference counted object is removed, the object will spontaneously destruct.

To create an instance of class vtk\-Object, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkObject
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Object has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Object class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Object = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Object = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Debug\-On ()} -\/ Turn debugging output on.  
\item {\ttfamily obj.\-Debug\-Off ()} -\/ Turn debugging output off.  
\item {\ttfamily char = obj.\-Get\-Debug ()} -\/ Get the value of the debug flag.  
\item {\ttfamily obj.\-Set\-Debug (char debug\-Flag)} -\/ Set the value of the debug flag. A non-\/zero value turns debugging on.  
\item {\ttfamily obj.\-Modified ()} -\/ Update the modification time for this object. Many filters rely on the modification time to determine if they need to recompute their data. The modification time is a unique monotonically increasing unsigned long integer.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return this object's modified time.  
\item {\ttfamily obj.\-Remove\-Observer (long tag)} -\/ Allow people to add/remove/invoke observers (callbacks) to any V\-T\-K object. This is an implementation of the subject/observer design pattern. An observer is added by specifying an event to respond to and a vtk\-Command to execute. It returns an unsigned long tag which can be used later to remove the event or retrieve the command. When events are invoked, the observers are called in the order they were added. If a priority value is specified, then the higher priority commands are called first. A command may set an abort flag to stop processing of the event. (See vtk\-Command.\-h for more information.)  
\item {\ttfamily obj.\-Remove\-Observers (long event)} -\/ Allow people to add/remove/invoke observers (callbacks) to any V\-T\-K object. This is an implementation of the subject/observer design pattern. An observer is added by specifying an event to respond to and a vtk\-Command to execute. It returns an unsigned long tag which can be used later to remove the event or retrieve the command. When events are invoked, the observers are called in the order they were added. If a priority value is specified, then the higher priority commands are called first. A command may set an abort flag to stop processing of the event. (See vtk\-Command.\-h for more information.)  
\item {\ttfamily obj.\-Remove\-Observers (string event)} -\/ Allow people to add/remove/invoke observers (callbacks) to any V\-T\-K object. This is an implementation of the subject/observer design pattern. An observer is added by specifying an event to respond to and a vtk\-Command to execute. It returns an unsigned long tag which can be used later to remove the event or retrieve the command. When events are invoked, the observers are called in the order they were added. If a priority value is specified, then the higher priority commands are called first. A command may set an abort flag to stop processing of the event. (See vtk\-Command.\-h for more information.)  
\item {\ttfamily obj.\-Remove\-All\-Observers ()} -\/ Allow people to add/remove/invoke observers (callbacks) to any V\-T\-K object. This is an implementation of the subject/observer design pattern. An observer is added by specifying an event to respond to and a vtk\-Command to execute. It returns an unsigned long tag which can be used later to remove the event or retrieve the command. When events are invoked, the observers are called in the order they were added. If a priority value is specified, then the higher priority commands are called first. A command may set an abort flag to stop processing of the event. (See vtk\-Command.\-h for more information.)  
\item {\ttfamily int = obj.\-Has\-Observer (long event)} -\/ Allow people to add/remove/invoke observers (callbacks) to any V\-T\-K object. This is an implementation of the subject/observer design pattern. An observer is added by specifying an event to respond to and a vtk\-Command to execute. It returns an unsigned long tag which can be used later to remove the event or retrieve the command. When events are invoked, the observers are called in the order they were added. If a priority value is specified, then the higher priority commands are called first. A command may set an abort flag to stop processing of the event. (See vtk\-Command.\-h for more information.)  
\item {\ttfamily int = obj.\-Has\-Observer (string event)} -\/ Allow people to add/remove/invoke observers (callbacks) to any V\-T\-K object. This is an implementation of the subject/observer design pattern. An observer is added by specifying an event to respond to and a vtk\-Command to execute. It returns an unsigned long tag which can be used later to remove the event or retrieve the command. When events are invoked, the observers are called in the order they were added. If a priority value is specified, then the higher priority commands are called first. A command may set an abort flag to stop processing of the event. (See vtk\-Command.\-h for more information.)  
\item {\ttfamily int = obj.\-Invoke\-Event (long event)}  
\item {\ttfamily int = obj.\-Invoke\-Event (string event)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkobjectbase}{}\section{vtk\-Object\-Base}\label{vtkcommon_vtkobjectbase}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Object\-Base is the base class for all reference counted classes in the V\-T\-K. These classes include vtk\-Command classes, vtk\-Information\-Key classes, and vtk\-Object classes.

vtk\-Object\-Base performs reference counting\-: objects that are reference counted exist as long as another object uses them. Once the last reference to a reference counted object is removed, the object will spontaneously destruct.

Constructor and destructor of the subclasses of vtk\-Object\-Base should be protected, so that only New() and Un\-Register() actually call them. Debug leaks can be used to see if there are any objects left with nonzero reference count.

To create an instance of class vtk\-Object\-Base, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkObjectBase
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Object\-Base has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Object\-Base class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name () const} -\/ Return the class name as a string. This method is defined in all subclasses of vtk\-Object\-Base with the vtk\-Type\-Revision\-Macro found in vtk\-Set\-Get.\-h.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtk\-Type\-Revision\-Macro found in vtk\-Set\-Get.\-h.  
\item {\ttfamily obj.\-Delete ()} -\/ Delete a V\-T\-K object. This method should always be used to delete an object when the New() method was used to create it. Using the C++ delete method will not work with reference counting.  
\item {\ttfamily obj.\-Fast\-Delete ()} -\/ Delete a reference to this object. This version will not invoke garbage collection and can potentially leak the object if it is part of a reference loop. Use this method only when it is known that the object has another reference and would not be collected if a full garbage collection check were done.  
\item {\ttfamily obj.\-Register (vtk\-Object\-Base o)} -\/ Increase the reference count (mark as used by another object).  
\item {\ttfamily obj.\-Un\-Register (vtk\-Object\-Base o)} -\/ Decrease the reference count (release by another object). This has the same effect as invoking Delete() (i.\-e., it reduces the reference count by 1).  
\item {\ttfamily int = obj.\-Get\-Reference\-Count ()} -\/ Sets the reference count. (This is very dangerous, use with care.)  
\item {\ttfamily obj.\-Set\-Reference\-Count (int )} -\/ Sets the reference count. (This is very dangerous, use with care.)  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkobjectfactory}{}\section{vtk\-Object\-Factory}\label{vtkcommon_vtkobjectfactory}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Object\-Factory is used to create vtk objects. The base class vtk\-Object\-Factory contains a static method Create\-Instance which is used to create vtk objects from the list of registered vtk\-Object\-Factory sub-\/classes. The first time Create\-Instance is called, all dll's or shared libraries in the environment variable V\-T\-K\-\_\-\-A\-U\-T\-O\-L\-O\-A\-D\-\_\-\-P\-A\-T\-H are loaded into the current process. The C functions vtk\-Load, vtk\-Get\-Factory\-Compiler\-Used, and vtk\-Get\-Factory\-Version are called on each dll. To implement these functions in a shared library or dll, use the macro\-: V\-T\-K\-\_\-\-F\-A\-C\-T\-O\-R\-Y\-\_\-\-I\-N\-T\-E\-R\-F\-A\-C\-E\-\_\-\-I\-M\-P\-L\-E\-M\-E\-N\-T. V\-T\-K\-\_\-\-A\-U\-T\-O\-L\-O\-A\-D\-\_\-\-P\-A\-T\-H is an environment variable containing a colon separated (semi-\/colon on win32) list of paths.

The vtk\-Object\-Factory can be use to override the creation of any object in V\-T\-K with a sub-\/class of that object. The factories can be registered either at run time with the V\-T\-K\-\_\-\-A\-U\-T\-O\-L\-O\-A\-D\-\_\-\-P\-A\-T\-H, or at compile time with the vtk\-Object\-Factory\-::\-Register\-Factory method.

To create an instance of class vtk\-Object\-Factory, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkObjectFactory
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Object\-Factory has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Object\-Factory class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Object\-Factory = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Object\-Factory = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily string = obj.\-Get\-V\-T\-K\-Source\-Version ()} -\/ All sub-\/classes of vtk\-Object\-Factory should must return the version of V\-T\-K they were built with. This should be implemented with the macro V\-T\-K\-\_\-\-S\-O\-U\-R\-C\-E\-\_\-\-V\-E\-R\-S\-I\-O\-N and N\-O\-T a call to vtk\-Version\-::\-Get\-V\-T\-K\-Source\-Version. As the version needs to be compiled into the file as a string constant. This is critical to determine possible incompatible dynamic factory loads.  
\item {\ttfamily string = obj.\-Get\-Description ()} -\/ Return a descriptive string describing the factory.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Overrides ()} -\/ Return number of overrides this factory can create.  
\item {\ttfamily string = obj.\-Get\-Class\-Override\-Name (int index)} -\/ Return the name of a class override at the given index.  
\item {\ttfamily string = obj.\-Get\-Class\-Override\-With\-Name (int index)} -\/ Return the name of the class that will override the class at the given index  
\item {\ttfamily int = obj.\-Get\-Enable\-Flag (int index)} -\/ Return the enable flag for the class at the given index.  
\item {\ttfamily string = obj.\-Get\-Override\-Description (int index)} -\/ Return the description for a the class override at the given index.  
\item {\ttfamily obj.\-Set\-Enable\-Flag (int flag, string class\-Name, string subclass\-Name)} -\/ Set and Get the Enable flag for the specific override of class\-Name. if subclass\-Name is null, then it is ignored.  
\item {\ttfamily int = obj.\-Get\-Enable\-Flag (string class\-Name, string subclass\-Name)} -\/ Set and Get the Enable flag for the specific override of class\-Name. if subclass\-Name is null, then it is ignored.  
\item {\ttfamily int = obj.\-Has\-Override (string class\-Name)} -\/ Return 1 if this factory overrides the given class name, 0 otherwise.  
\item {\ttfamily int = obj.\-Has\-Override (string class\-Name, string subclass\-Name)} -\/ Return 1 if this factory overrides the given class name, 0 otherwise.  
\item {\ttfamily obj.\-Disable (string class\-Name)} -\/ Set all enable flags for the given class to 0. This will mean that the factory will stop producing class with the given name.  
\item {\ttfamily string = obj.\-Get\-Library\-Path ()} -\/ This returns the path to a dynamically loaded factory.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkobjectfactorycollection}{}\section{vtk\-Object\-Factory\-Collection}\label{vtkcommon_vtkobjectfactorycollection}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Object\-Factory\-Collection is an object that creates and manipulates lists of object of type vtk\-Object\-Factory.

To create an instance of class vtk\-Object\-Factory\-Collection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkObjectFactoryCollection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Object\-Factory\-Collection has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Object\-Factory\-Collection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Object\-Factory\-Collection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Object\-Factory\-Collection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Item (vtk\-Object\-Factory t)} -\/ Get the next Object\-Factory in the list. Return N\-U\-L\-L when the end of the list is reached.  
\item {\ttfamily vtk\-Object\-Factory = obj.\-Get\-Next\-Item ()}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkoutputwindow}{}\section{vtk\-Output\-Window}\label{vtkcommon_vtkoutputwindow}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is used to encapsulate all text output, so that it will work with operating systems that have a stdout and stderr, and ones that do not. (i.\-e windows does not). Sub-\/classes can be provided which can redirect the output to a window.

To create an instance of class vtk\-Output\-Window, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOutputWindow
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Output\-Window has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Output\-Window class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Output\-Window = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Output\-Window = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Display\-Text (string )} -\/ Display the text. Four virtual methods exist, depending on the type of message to display. This allows redirection or reformatting of the messages. The default implementation uses Display\-Text for all.  
\item {\ttfamily obj.\-Display\-Error\-Text (string )} -\/ Display the text. Four virtual methods exist, depending on the type of message to display. This allows redirection or reformatting of the messages. The default implementation uses Display\-Text for all.  
\item {\ttfamily obj.\-Display\-Warning\-Text (string )} -\/ Display the text. Four virtual methods exist, depending on the type of message to display. This allows redirection or reformatting of the messages. The default implementation uses Display\-Text for all.  
\item {\ttfamily obj.\-Display\-Generic\-Warning\-Text (string )} -\/ Display the text. Four virtual methods exist, depending on the type of message to display. This allows redirection or reformatting of the messages. The default implementation uses Display\-Text for all.  
\item {\ttfamily obj.\-Display\-Debug\-Text (string )}  
\item {\ttfamily obj.\-Prompt\-User\-On ()} -\/ If Prompt\-User is set to true then each time a line of text is displayed, the user is asked if they want to keep getting messages.  
\item {\ttfamily obj.\-Prompt\-User\-Off ()} -\/ If Prompt\-User is set to true then each time a line of text is displayed, the user is asked if they want to keep getting messages.  
\item {\ttfamily obj.\-Set\-Prompt\-User (int )} -\/ If Prompt\-User is set to true then each time a line of text is displayed, the user is asked if they want to keep getting messages.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkoverrideinformation}{}\section{vtk\-Override\-Information}\label{vtkcommon_vtkoverrideinformation}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Override\-Information is used to represent the information about a class which is overriden in a vtk\-Object\-Factory.

To create an instance of class vtk\-Override\-Information, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOverrideInformation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Override\-Information has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Override\-Information class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Override\-Information = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Override\-Information = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily string = obj.\-Get\-Class\-Override\-Name ()} -\/ Returns the name of the class that will override the class. For example, if you had a factory that provided an override for vtk\-Vertex called vtk\-My\-Vertex, then this would return \char`\"{}vtk\-My\-Vertex\char`\"{}  
\item {\ttfamily string = obj.\-Get\-Class\-Override\-With\-Name ()} -\/ Return a human readable or G\-U\-I displayable description of this override.  
\item {\ttfamily string = obj.\-Get\-Description ()} -\/ Return the specific object factory that this override occurs in.  
\item {\ttfamily vtk\-Object\-Factory = obj.\-Get\-Object\-Factory ()} -\/ Set the class override name  
\item {\ttfamily obj.\-Set\-Class\-Override\-Name (string )} -\/ Set the class override name  
\item {\ttfamily obj.\-Set\-Class\-Override\-With\-Name (string )} -\/ Set the class override name Set the class override with name  
\item {\ttfamily obj.\-Set\-Description (string )} -\/ Set the class override name Set the class override with name Set the description  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkoverrideinformationcollection}{}\section{vtk\-Override\-Information\-Collection}\label{vtkcommon_vtkoverrideinformationcollection}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Override\-Information\-Collection is an object that creates and manipulates lists of objects of type vtk\-Override\-Information.

To create an instance of class vtk\-Override\-Information\-Collection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOverrideInformationCollection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Override\-Information\-Collection has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Override\-Information\-Collection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Override\-Information\-Collection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Override\-Information\-Collection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Item (vtk\-Override\-Information )} -\/ Add a Override\-Information to the list.  
\item {\ttfamily vtk\-Override\-Information = obj.\-Get\-Next\-Item ()} -\/ Get the next Override\-Information in the list.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkparametricboy}{}\section{vtk\-Parametric\-Boy}\label{vtkcommon_vtkparametricboy}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Parametric\-Boy generates Boy's surface. This is a Model of the projective plane without singularities. It was found by Werner Boy on assignment from David Hilbert.

For further information about this surface, please consult the technical description \char`\"{}\-Parametric surfaces\char`\"{} in \href{http://www.vtk.org/documents.php}{\tt http\-://www.\-vtk.\-org/documents.\-php} in the \char`\"{}\-V\-T\-K Technical Documents\char`\"{} section in the V\-Tk.\-org web pages.

.S\-E\-C\-T\-I\-O\-N Thanks Andrew Maclean \href{mailto:a.maclean@cas.edu.au}{\tt a.\-maclean@cas.\-edu.\-au} for creating and contributing the class.

To create an instance of class vtk\-Parametric\-Boy, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkParametricBoy
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Parametric\-Boy has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Parametric\-Boy class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Parametric\-Boy = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Parametric\-Boy = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Dimension ()} -\/ Set/\-Get the scale factor for the z-\/coordinate. Default = 1/8, giving a nice shape.  
\item {\ttfamily obj.\-Set\-Z\-Scale (double )} -\/ Set/\-Get the scale factor for the z-\/coordinate. Default = 1/8, giving a nice shape.  
\item {\ttfamily double = obj.\-Get\-Z\-Scale ()} -\/ Set/\-Get the scale factor for the z-\/coordinate. Default = 1/8, giving a nice shape.  
\item {\ttfamily obj.\-Evaluate (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ Boy's surface.

This function performs the mapping $f(u,v) \rightarrow (x,y,x)$, returning it as Pt. It also returns the partial derivatives Du and Dv. $Pt = (x, y, z), Du = (dx/du, dy/du, dz/du), Dv = (dx/dv, dy/dv, dz/dv)$ . Then the normal is $N = Du X Dv$ .  
\item {\ttfamily double = obj.\-Evaluate\-Scalar (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ Calculate a user defined scalar using one or all of uvw, Pt, Duvw.

uvw are the parameters with Pt being the the cartesian point, Duvw are the derivatives of this point with respect to u, v and w. Pt, Duvw are obtained from Evaluate().

This function is only called if the Scalar\-Mode has the value vtk\-Parametric\-Function\-Source\-::\-S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D

If the user does not need to calculate a scalar, then the instantiated function should return zero.


\end{DoxyItemize}\hypertarget{vtkcommon_vtkparametricconicspiral}{}\section{vtk\-Parametric\-Conic\-Spiral}\label{vtkcommon_vtkparametricconicspiral}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Parametric\-Conic\-Spiral generates conic spiral surfaces. These can resemble sea shells, or may look like a torus \char`\"{}eating\char`\"{} its own tail.

For further information about this surface, please consult the technical description \char`\"{}\-Parametric surfaces\char`\"{} in \href{http://www.vtk.org/documents.php}{\tt http\-://www.\-vtk.\-org/documents.\-php} in the \char`\"{}\-V\-T\-K Technical Documents\char`\"{} section in the V\-Tk.\-org web pages.

.S\-E\-C\-T\-I\-O\-N Thanks Andrew Maclean \href{mailto:a.maclean@cas.edu.au}{\tt a.\-maclean@cas.\-edu.\-au} for creating and contributing the class.

To create an instance of class vtk\-Parametric\-Conic\-Spiral, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkParametricConicSpiral
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Parametric\-Conic\-Spiral has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Parametric\-Conic\-Spiral class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Parametric\-Conic\-Spiral = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Parametric\-Conic\-Spiral = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Dimension ()} -\/ Set/\-Get the scale factor. Default = 0.\-2  
\item {\ttfamily obj.\-Set\-A (double )} -\/ Set/\-Get the scale factor. Default = 0.\-2  
\item {\ttfamily double = obj.\-Get\-A ()} -\/ Set/\-Get the scale factor. Default = 0.\-2  
\item {\ttfamily obj.\-Set\-B (double )} -\/ Set/\-Get the A function coefficient (see equation below). Default = 1.  
\item {\ttfamily double = obj.\-Get\-B ()} -\/ Set/\-Get the A function coefficient (see equation below). Default = 1.  
\item {\ttfamily obj.\-Set\-C (double )} -\/ Set/\-Get the B function coefficient (see equation below). Default = 0.\-1.  
\item {\ttfamily double = obj.\-Get\-C ()} -\/ Set/\-Get the B function coefficient (see equation below). Default = 0.\-1.  
\item {\ttfamily obj.\-Set\-N (double )} -\/ Set/\-Get the C function coefficient (see equation below). Default = 2.  
\item {\ttfamily double = obj.\-Get\-N ()} -\/ Set/\-Get the C function coefficient (see equation below). Default = 2.  
\item {\ttfamily obj.\-Evaluate (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ A conic spiral surface.

This function performs the mapping $f(u,v) \rightarrow (x,y,x)$, returning it as Pt. It also returns the partial derivatives Du and Dv. $Pt = (x, y, z), Du = (dx/du, dy/du, dz/du), Dv = (dx/dv, dy/dv, dz/dv)$ . Then the normal is $N = Du X Dv$ .  
\item {\ttfamily double = obj.\-Evaluate\-Scalar (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ Calculate a user defined scalar using one or all of uvw, Pt, Duvw.

uvw are the parameters with Pt being the the cartesian point, Duvw are the derivatives of this point with respect to u, v and w. Pt, Duvw are obtained from Evaluate().

This function is only called if the Scalar\-Mode has the value vtk\-Parametric\-Function\-Source\-::\-S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D

If the user does not need to calculate a scalar, then the instantiated function should return zero.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkparametriccrosscap}{}\section{vtk\-Parametric\-Cross\-Cap}\label{vtkcommon_vtkparametriccrosscap}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Parametric\-Cross\-Cap generates a cross-\/cap which is a non-\/orientable self-\/intersecting single-\/sided surface. This is one possible image of a projective plane in three-\/space.

For further information about this surface, please consult the technical description \char`\"{}\-Parametric surfaces\char`\"{} in \href{http://www.vtk.org/documents.php}{\tt http\-://www.\-vtk.\-org/documents.\-php} in the \char`\"{}\-V\-T\-K Technical Documents\char`\"{} section in the V\-Tk.\-org web pages.

.S\-E\-C\-T\-I\-O\-N Thanks Andrew Maclean \href{mailto:a.maclean@cas.edu.au}{\tt a.\-maclean@cas.\-edu.\-au} for creating and contributing the class.

To create an instance of class vtk\-Parametric\-Cross\-Cap, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkParametricCrossCap
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Parametric\-Cross\-Cap has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Parametric\-Cross\-Cap class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Parametric\-Cross\-Cap = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Parametric\-Cross\-Cap = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Dimension ()} -\/ A cross-\/cap.

This function performs the mapping $f(u,v) \rightarrow (x,y,x)$, returning it as Pt. It also returns the partial derivatives Du and Dv. $Pt = (x, y, z), Du = (dx/du, dy/du, dz/du), Dv = (dx/dv, dy/dv, dz/dv)$ . Then the normal is $N = Du X Dv$ .  
\item {\ttfamily obj.\-Evaluate (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ A cross-\/cap.

This function performs the mapping $f(u,v) \rightarrow (x,y,x)$, returning it as Pt. It also returns the partial derivatives Du and Dv. $Pt = (x, y, z), Du = (dx/du, dy/du, dz/du), Dv = (dx/dv, dy/dv, dz/dv)$ . Then the normal is $N = Du X Dv$ .  
\item {\ttfamily double = obj.\-Evaluate\-Scalar (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ Calculate a user defined scalar using one or all of uvw, Pt, Duvw.

uvw are the parameters with Pt being the the cartesian point, Duvw are the derivatives of this point with respect to u, v and w. Pt, Duvw are obtained from Evaluate().

This function is only called if the Scalar\-Mode has the value vtk\-Parametric\-Function\-Source\-::\-S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D

If the user does not need to calculate a scalar, then the instantiated function should return zero.


\end{DoxyItemize}\hypertarget{vtkcommon_vtkparametricdini}{}\section{vtk\-Parametric\-Dini}\label{vtkcommon_vtkparametricdini}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Parametric\-Dini generates Dini's surface. Dini's surface is a surface that posesses constant negative Gaussian curvature

For further information about this surface, please consult the technical description \char`\"{}\-Parametric surfaces\char`\"{} in \href{http://www.vtk.org/documents.php}{\tt http\-://www.\-vtk.\-org/documents.\-php} in the \char`\"{}\-V\-T\-K Technical Documents\char`\"{} section in the V\-Tk.\-org web pages.

.S\-E\-C\-T\-I\-O\-N Thanks Andrew Maclean \href{mailto:a.maclean@cas.edu.au}{\tt a.\-maclean@cas.\-edu.\-au} for creating and contributing the class.

To create an instance of class vtk\-Parametric\-Dini, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkParametricDini
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Parametric\-Dini has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Parametric\-Dini class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Parametric\-Dini = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Parametric\-Dini = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Dimension ()} -\/ Set/\-Get the scale factor. Default = 1.  
\item {\ttfamily obj.\-Set\-A (double )} -\/ Set/\-Get the scale factor. Default = 1.  
\item {\ttfamily double = obj.\-Get\-A ()} -\/ Set/\-Get the scale factor. Default = 1.  
\item {\ttfamily obj.\-Set\-B (double )} -\/ Set/\-Get the scale factor. Default = 0.\-2  
\item {\ttfamily double = obj.\-Get\-B ()} -\/ Set/\-Get the scale factor. Default = 0.\-2  
\item {\ttfamily obj.\-Evaluate (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ Dini's surface.

This function performs the mapping $f(u,v) \rightarrow (x,y,x)$, returning it as Pt. It also returns the partial derivatives Du and Dv. $Pt = (x, y, z), Du = (dx/du, dy/du, dz/du), Dv = (dx/dv, dy/dv, dz/dv)$ . Then the normal is $N = Du X Dv$ .  
\item {\ttfamily double = obj.\-Evaluate\-Scalar (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ Calculate a user defined scalar using one or all of uvw, Pt, Duvw.

uvw are the parameters with Pt being the the cartesian point, Duvw are the derivatives of this point with respect to u, v and w. Pt, Duvw are obtained from Evaluate().

This function is only called if the Scalar\-Mode has the value vtk\-Parametric\-Function\-Source\-::\-S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D

If the user does not need to calculate a scalar, then the instantiated function should return zero.


\end{DoxyItemize}\hypertarget{vtkcommon_vtkparametricellipsoid}{}\section{vtk\-Parametric\-Ellipsoid}\label{vtkcommon_vtkparametricellipsoid}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Parametric\-Ellipsoid generates an ellipsoid. If all the radii are the same, we have a sphere. An oblate spheroid occurs if Radius\-X = Radius\-Y $>$ Radius\-Z. Here the Z-\/axis forms the symmetry axis. To a first approximation, this is the shape of the earth. A prolate spheroid occurs if Radius\-X = Radius\-Y $<$ Radius\-Z.

For further information about this surface, please consult the technical description \char`\"{}\-Parametric surfaces\char`\"{} in \href{http://www.vtk.org/documents.php}{\tt http\-://www.\-vtk.\-org/documents.\-php} in the \char`\"{}\-V\-T\-K Technical Documents\char`\"{} section in the V\-Tk.\-org web pages.

.S\-E\-C\-T\-I\-O\-N Thanks Andrew Maclean \href{mailto:a.maclean@cas.edu.au}{\tt a.\-maclean@cas.\-edu.\-au} for creating and contributing the class.

To create an instance of class vtk\-Parametric\-Ellipsoid, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkParametricEllipsoid
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Parametric\-Ellipsoid has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Parametric\-Ellipsoid class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Parametric\-Ellipsoid = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Parametric\-Ellipsoid = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Dimension ()} -\/ Set/\-Get the scaling factor for the x-\/axis. Default = 1.  
\item {\ttfamily obj.\-Set\-X\-Radius (double )} -\/ Set/\-Get the scaling factor for the x-\/axis. Default = 1.  
\item {\ttfamily double = obj.\-Get\-X\-Radius ()} -\/ Set/\-Get the scaling factor for the x-\/axis. Default = 1.  
\item {\ttfamily obj.\-Set\-Y\-Radius (double )} -\/ Set/\-Get the scaling factor for the y-\/axis. Default = 1.  
\item {\ttfamily double = obj.\-Get\-Y\-Radius ()} -\/ Set/\-Get the scaling factor for the y-\/axis. Default = 1.  
\item {\ttfamily obj.\-Set\-Z\-Radius (double )} -\/ Set/\-Get the scaling factor for the z-\/axis. Default = 1.  
\item {\ttfamily double = obj.\-Get\-Z\-Radius ()} -\/ Set/\-Get the scaling factor for the z-\/axis. Default = 1.  
\item {\ttfamily obj.\-Evaluate (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ An ellipsoid.

This function performs the mapping $f(u,v) \rightarrow (x,y,x)$, returning it as Pt. It also returns the partial derivatives Du and Dv. $Pt = (x, y, z), Du = (dx/du, dy/du, dz/du), Dv = (dx/dv, dy/dv, dz/dv)$ . Then the normal is $N = Du X Dv$ .  
\item {\ttfamily double = obj.\-Evaluate\-Scalar (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ Calculate a user defined scalar using one or all of uvw, Pt, Duvw.

uvw are the parameters with Pt being the the cartesian point, Duvw are the derivatives of this point with respect to u, v and w. Pt, Duvw are obtained from Evaluate().

This function is only called if the Scalar\-Mode has the value vtk\-Parametric\-Function\-Source\-::\-S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D

If the user does not need to calculate a scalar, then the instantiated function should return zero.


\end{DoxyItemize}\hypertarget{vtkcommon_vtkparametricenneper}{}\section{vtk\-Parametric\-Enneper}\label{vtkcommon_vtkparametricenneper}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Parametric\-Enneper generates Enneper's surface. Enneper's surface is a a self-\/intersecting minimal surface posessing constant negative Gaussian curvature

For further information about this surface, please consult the technical description \char`\"{}\-Parametric surfaces\char`\"{} in \href{http://www.vtk.org/documents.php}{\tt http\-://www.\-vtk.\-org/documents.\-php} in the \char`\"{}\-V\-T\-K Technical Documents\char`\"{} section in the V\-Tk.\-org web pages.

.S\-E\-C\-T\-I\-O\-N Thanks Andrew Maclean \href{mailto:a.maclean@cas.edu.au}{\tt a.\-maclean@cas.\-edu.\-au} for creating and contributing the class.

To create an instance of class vtk\-Parametric\-Enneper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkParametricEnneper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Parametric\-Enneper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Parametric\-Enneper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Parametric\-Enneper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Parametric\-Enneper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Dimension ()} -\/ Enneper's surface.

This function performs the mapping $f(u,v) \rightarrow (x,y,x)$, returning it as Pt. It also returns the partial derivatives Du and Dv. $Pt = (x, y, z), Du = (dx/du, dy/du, dz/du), Dv = (dx/dv, dy/dv, dz/dv)$ . Then the normal is $N = Du X Dv$ .  
\item {\ttfamily obj.\-Evaluate (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ Enneper's surface.

This function performs the mapping $f(u,v) \rightarrow (x,y,x)$, returning it as Pt. It also returns the partial derivatives Du and Dv. $Pt = (x, y, z), Du = (dx/du, dy/du, dz/du), Dv = (dx/dv, dy/dv, dz/dv)$ . Then the normal is $N = Du X Dv$ .  
\item {\ttfamily double = obj.\-Evaluate\-Scalar (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ Calculate a user defined scalar using one or all of uvw, Pt, Duvw.

uv are the parameters with Pt being the the cartesian point, Duvw are the derivatives of this point with respect to u, v and w. Pt, Duvw are obtained from Evaluate().

This function is only called if the Scalar\-Mode has the value vtk\-Parametric\-Function\-Source\-::\-S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D

If the user does not need to calculate a scalar, then the instantiated function should return zero.


\end{DoxyItemize}\hypertarget{vtkcommon_vtkparametricfigure8klein}{}\section{vtk\-Parametric\-Figure8\-Klein}\label{vtkcommon_vtkparametricfigure8klein}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Parametric\-Figure8\-Klein generates a figure-\/8 Klein bottle. A Klein bottle is a closed surface with no interior and only one surface. It is unrealisable in 3 dimensions without intersecting surfaces. It can be realised in 4 dimensions by considering the map $F:R^2 \rightarrow R^4$ given by\-:


\begin{DoxyItemize}
\item $f(u,v) = ((r*cos(v)+a)*cos(u),(r*cos(v)+a)*sin(u),r*sin(v)*cos(u/2),r*sin(v)*sin(u/2))$
\end{DoxyItemize}

This representation of the immersion in $R^3$ is formed by taking two Mobius strips and joining them along their boundaries, this is the so called \char`\"{}\-Figure-\/8 Klein Bottle\char`\"{}

For further information about this surface, please consult the technical description \char`\"{}\-Parametric surfaces\char`\"{} in \href{http://www.vtk.org/documents.php}{\tt http\-://www.\-vtk.\-org/documents.\-php} in the \char`\"{}\-V\-T\-K Technical Documents\char`\"{} section in the V\-Tk.\-org web pages.

.S\-E\-C\-T\-I\-O\-N Thanks Andrew Maclean \href{mailto:a.maclean@cas.edu.au}{\tt a.\-maclean@cas.\-edu.\-au} for creating and contributing the class.

To create an instance of class vtk\-Parametric\-Figure8\-Klein, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkParametricFigure8Klein
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Parametric\-Figure8\-Klein has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Parametric\-Figure8\-Klein class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Parametric\-Figure8\-Klein = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Parametric\-Figure8\-Klein = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Radius (double )} -\/ Set/\-Get the radius of the bottle.  
\item {\ttfamily double = obj.\-Get\-Radius ()} -\/ Set/\-Get the radius of the bottle.  
\item {\ttfamily int = obj.\-Get\-Dimension ()} -\/ A Figure-\/8 Klein bottle.

This function performs the mapping $f(u,v) \rightarrow (x,y,x)$, returning it as Pt. It also returns the partial derivatives Du and Dv. $Pt = (x, y, z), Du = (dx/du, dy/du, dz/du), Dv = (dx/dv, dy/dv, dz/dv)$ . Then the normal is $N = Du X Dv$ .  
\item {\ttfamily obj.\-Evaluate (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ A Figure-\/8 Klein bottle.

This function performs the mapping $f(u,v) \rightarrow (x,y,x)$, returning it as Pt. It also returns the partial derivatives Du and Dv. $Pt = (x, y, z), Du = (dx/du, dy/du, dz/du), Dv = (dx/dv, dy/dv, dz/dv)$ . Then the normal is $N = Du X Dv$ .  
\item {\ttfamily double = obj.\-Evaluate\-Scalar (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ Calculate a user defined scalar using one or all of uvw, Pt, Duvw.

uvw are the parameters with Pt being the the cartesian point, Duvw are the derivatives of this point with respect to u, v and w. Pt, Duvw are obtained from Evaluate().

This function is only called if the Scalar\-Mode has the value vtk\-Parametric\-Function\-Source\-::\-S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D

If the user does not need to calculate a scalar, then the instantiated function should return zero.


\end{DoxyItemize}\hypertarget{vtkcommon_vtkparametricfunction}{}\section{vtk\-Parametric\-Function}\label{vtkcommon_vtkparametricfunction}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Parametric\-Function is an abstract interface for functions defined by parametric mapping i.\-e. f(u,v,w)-\/$>$(x,y,z) where u\-\_\-min $<$= u $<$ u\-\_\-max, v\-\_\-min $<$= v $<$ v\-\_\-max, w\-\_\-min $<$= w $<$ w\-\_\-max. (For notational convenience, we will write f(u)-\/$>$x and assume that u means (u,v,w) and x means (x,y,z).)

The interface contains the pure virtual function, Evaluate(), that generates a point and the derivatives at that point which are then used to construct the surface. A second pure virtual function, Evaluate\-Scalar(), can be used to generate a scalar for the surface. Finally, the Get\-Dimension() virtual function is used to differentiate 1\-D, 2\-D, and 3\-D parametric functions. Since this abstract class defines a pure virtual A\-P\-I, its subclasses must implement the pure virtual functions Get\-Dimension(), Evaluate() and Evaluate\-Scalar().

This class has also methods for defining a range of parametric values (u,v,w).

.S\-E\-C\-T\-I\-O\-N Thanks Andrew Maclean \href{mailto:a.maclean@cas.edu.au}{\tt a.\-maclean@cas.\-edu.\-au} for creating and contributing the class.

To create an instance of class vtk\-Parametric\-Function, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkParametricFunction
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Parametric\-Function has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Parametric\-Function class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Parametric\-Function = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Parametric\-Function = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Dimension ()}  
\item {\ttfamily obj.\-Evaluate (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ Performs the mapping \$f(uvw)-\/$>$(Pt,Duvw)\$f. This is a pure virtual function that must be instantiated in a derived class.

uvw are the parameters, with u corresponding to uvw\mbox{[}0\mbox{]}, v to uvw\mbox{[}1\mbox{]} and w to uvw\mbox{[}2\mbox{]} respectively. Pt is the returned Cartesian point, Duvw are the derivatives of this point with respect to u, v and w. Note that the first three values in Duvw are Du, the next three are Dv, and the final three are Dw. Du Dv Dw are the partial derivatives of the function at the point Pt with respect to u, v and w respectively.  
\item {\ttfamily double = obj.\-Evaluate\-Scalar (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ Calculate a user defined scalar using one or all of uvw, Pt, Duvw. This is a pure virtual function that must be instantiated in a derived class.

uvw are the parameters with Pt being the the cartesian point, Duvw are the derivatives of this point with respect to u, v, and w. Pt, Duvw are obtained from Evaluate().  
\item {\ttfamily obj.\-Set\-Minimum\-U (double )} -\/ Set/\-Get the minimum u-\/value.  
\item {\ttfamily double = obj.\-Get\-Minimum\-U ()} -\/ Set/\-Get the minimum u-\/value.  
\item {\ttfamily obj.\-Set\-Maximum\-U (double )} -\/ Set/\-Get the maximum u-\/value.  
\item {\ttfamily double = obj.\-Get\-Maximum\-U ()} -\/ Set/\-Get the maximum u-\/value.  
\item {\ttfamily obj.\-Set\-Minimum\-V (double )} -\/ Set/\-Get the minimum v-\/value.  
\item {\ttfamily double = obj.\-Get\-Minimum\-V ()} -\/ Set/\-Get the minimum v-\/value.  
\item {\ttfamily obj.\-Set\-Maximum\-V (double )} -\/ Set/\-Get the maximum v-\/value.  
\item {\ttfamily double = obj.\-Get\-Maximum\-V ()} -\/ Set/\-Get the maximum v-\/value.  
\item {\ttfamily obj.\-Set\-Minimum\-W (double )} -\/ Set/\-Get the minimum w-\/value.  
\item {\ttfamily double = obj.\-Get\-Minimum\-W ()} -\/ Set/\-Get the minimum w-\/value.  
\item {\ttfamily obj.\-Set\-Maximum\-W (double )} -\/ Set/\-Get the maximum w-\/value.  
\item {\ttfamily double = obj.\-Get\-Maximum\-W ()} -\/ Set/\-Get the maximum w-\/value.  
\item {\ttfamily obj.\-Set\-Join\-U (int )} -\/ Set/\-Get the flag which joins the first triangle strip to the last one.  
\item {\ttfamily int = obj.\-Get\-Join\-U ()} -\/ Set/\-Get the flag which joins the first triangle strip to the last one.  
\item {\ttfamily obj.\-Join\-U\-On ()} -\/ Set/\-Get the flag which joins the first triangle strip to the last one.  
\item {\ttfamily obj.\-Join\-U\-Off ()} -\/ Set/\-Get the flag which joins the first triangle strip to the last one.  
\item {\ttfamily obj.\-Set\-Join\-V (int )} -\/ Set/\-Get the flag which joins the the ends of the triangle strips.  
\item {\ttfamily int = obj.\-Get\-Join\-V ()} -\/ Set/\-Get the flag which joins the the ends of the triangle strips.  
\item {\ttfamily obj.\-Join\-V\-On ()} -\/ Set/\-Get the flag which joins the the ends of the triangle strips.  
\item {\ttfamily obj.\-Join\-V\-Off ()} -\/ Set/\-Get the flag which joins the the ends of the triangle strips.  
\item {\ttfamily obj.\-Set\-Twist\-U (int )} -\/ Set/\-Get the flag which joins the first triangle strip to the last one with a twist. Join\-U must also be set if this is set. Used when building some non-\/orientable surfaces.  
\item {\ttfamily int = obj.\-Get\-Twist\-U ()} -\/ Set/\-Get the flag which joins the first triangle strip to the last one with a twist. Join\-U must also be set if this is set. Used when building some non-\/orientable surfaces.  
\item {\ttfamily obj.\-Twist\-U\-On ()} -\/ Set/\-Get the flag which joins the first triangle strip to the last one with a twist. Join\-U must also be set if this is set. Used when building some non-\/orientable surfaces.  
\item {\ttfamily obj.\-Twist\-U\-Off ()} -\/ Set/\-Get the flag which joins the first triangle strip to the last one with a twist. Join\-U must also be set if this is set. Used when building some non-\/orientable surfaces.  
\item {\ttfamily obj.\-Set\-Twist\-V (int )} -\/ Set/\-Get the flag which joins the ends of the triangle strips with a twist. Join\-V must also be set if this is set. Used when building some non-\/orientable surfaces.  
\item {\ttfamily int = obj.\-Get\-Twist\-V ()} -\/ Set/\-Get the flag which joins the ends of the triangle strips with a twist. Join\-V must also be set if this is set. Used when building some non-\/orientable surfaces.  
\item {\ttfamily obj.\-Twist\-V\-On ()} -\/ Set/\-Get the flag which joins the ends of the triangle strips with a twist. Join\-V must also be set if this is set. Used when building some non-\/orientable surfaces.  
\item {\ttfamily obj.\-Twist\-V\-Off ()} -\/ Set/\-Get the flag which joins the ends of the triangle strips with a twist. Join\-V must also be set if this is set. Used when building some non-\/orientable surfaces.  
\item {\ttfamily obj.\-Set\-Clockwise\-Ordering (int )} -\/ Set/\-Get the flag which determines the ordering of the the vertices forming the triangle strips. The ordering of the points being inserted into the triangle strip is important because it determines the direction of the normals for the lighting. If set, the ordering is clockwise, otherwise the ordering is anti-\/clockwise. Default is true (i.\-e. clockwise ordering).  
\item {\ttfamily int = obj.\-Get\-Clockwise\-Ordering ()} -\/ Set/\-Get the flag which determines the ordering of the the vertices forming the triangle strips. The ordering of the points being inserted into the triangle strip is important because it determines the direction of the normals for the lighting. If set, the ordering is clockwise, otherwise the ordering is anti-\/clockwise. Default is true (i.\-e. clockwise ordering).  
\item {\ttfamily obj.\-Clockwise\-Ordering\-On ()} -\/ Set/\-Get the flag which determines the ordering of the the vertices forming the triangle strips. The ordering of the points being inserted into the triangle strip is important because it determines the direction of the normals for the lighting. If set, the ordering is clockwise, otherwise the ordering is anti-\/clockwise. Default is true (i.\-e. clockwise ordering).  
\item {\ttfamily obj.\-Clockwise\-Ordering\-Off ()} -\/ Set/\-Get the flag which determines the ordering of the the vertices forming the triangle strips. The ordering of the points being inserted into the triangle strip is important because it determines the direction of the normals for the lighting. If set, the ordering is clockwise, otherwise the ordering is anti-\/clockwise. Default is true (i.\-e. clockwise ordering).  
\item {\ttfamily obj.\-Set\-Derivatives\-Available (int )} -\/ Set/\-Get the flag which determines whether derivatives are available from the parametric function (i.\-e., whether the Evaluate() method returns valid derivatives).  
\item {\ttfamily int = obj.\-Get\-Derivatives\-Available ()} -\/ Set/\-Get the flag which determines whether derivatives are available from the parametric function (i.\-e., whether the Evaluate() method returns valid derivatives).  
\item {\ttfamily obj.\-Derivatives\-Available\-On ()} -\/ Set/\-Get the flag which determines whether derivatives are available from the parametric function (i.\-e., whether the Evaluate() method returns valid derivatives).  
\item {\ttfamily obj.\-Derivatives\-Available\-Off ()} -\/ Set/\-Get the flag which determines whether derivatives are available from the parametric function (i.\-e., whether the Evaluate() method returns valid derivatives).  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkparametricklein}{}\section{vtk\-Parametric\-Klein}\label{vtkcommon_vtkparametricklein}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Parametric\-Klein generates a \char`\"{}classical\char`\"{} representation of a Klein bottle. A Klein bottle is a closed surface with no interior and only one surface. It is unrealisable in 3 dimensions without intersecting surfaces. It can be realised in 4 dimensions by considering the map $F:R^2 \rightarrow R^4$ given by\-:


\begin{DoxyItemize}
\item $f(u,v) = ((r*cos(v)+a)*cos(u),(r*cos(v)+a)*sin(u),r*sin(v)*cos(u/2),r*sin(v)*sin(u/2))$
\end{DoxyItemize}

The classical representation of the immersion in $R^3$ is returned by this function.

For further information about this surface, please consult the technical description \char`\"{}\-Parametric surfaces\char`\"{} in \href{http://www.vtk.org/documents.php}{\tt http\-://www.\-vtk.\-org/documents.\-php} in the \char`\"{}\-V\-T\-K Technical Documents\char`\"{} section in the V\-Tk.\-org web pages.

.S\-E\-C\-T\-I\-O\-N Thanks Andrew Maclean \href{mailto:a.maclean@cas.edu.au}{\tt a.\-maclean@cas.\-edu.\-au} for creating and contributing the class.

To create an instance of class vtk\-Parametric\-Klein, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkParametricKlein
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Parametric\-Klein has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Parametric\-Klein class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Parametric\-Klein = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Parametric\-Klein = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Dimension ()} -\/ A Klein bottle.

This function performs the mapping $f(u,v) \rightarrow (x,y,x)$, returning it as Pt. It also returns the partial derivatives Du and Dv. $Pt = (x, y, z), Du = (dx/du, dy/du, dz/du), Dv = (dx/dv, dy/dv, dz/dv)$ . Then the normal is $N = Du X Dv$ .  
\item {\ttfamily obj.\-Evaluate (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ A Klein bottle.

This function performs the mapping $f(u,v) \rightarrow (x,y,x)$, returning it as Pt. It also returns the partial derivatives Du and Dv. $Pt = (x, y, z), Du = (dx/du, dy/du, dz/du), Dv = (dx/dv, dy/dv, dz/dv)$ . Then the normal is $N = Du X Dv$ .  
\item {\ttfamily double = obj.\-Evaluate\-Scalar (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ Calculate a user defined scalar using one or all of uvw, Pt, Duvw.

uvw are the parameters with Pt being the the cartesian point, Duvw are the derivatives of this point with respect to u, v and w. Pt, Duvw are obtained from Evaluate().

This function is only called if the Scalar\-Mode has the value vtk\-Parametric\-Function\-Source\-::\-S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D

If the user does not need to calculate a scalar, then the instantiated function should return zero.


\end{DoxyItemize}\hypertarget{vtkcommon_vtkparametricmobius}{}\section{vtk\-Parametric\-Mobius}\label{vtkcommon_vtkparametricmobius}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Parametric\-Mobius generates a Mobius strip.

For further information about this surface, please consult the technical description \char`\"{}\-Parametric surfaces\char`\"{} in \href{http://www.vtk.org/documents.php}{\tt http\-://www.\-vtk.\-org/documents.\-php} in the \char`\"{}\-V\-T\-K Technical Documents\char`\"{} section in the V\-Tk.\-org web pages.

.S\-E\-C\-T\-I\-O\-N Thanks Andrew Maclean \href{mailto:a.maclean@cas.edu.au}{\tt a.\-maclean@cas.\-edu.\-au} for creating and contributing the class.

To create an instance of class vtk\-Parametric\-Mobius, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkParametricMobius
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Parametric\-Mobius has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Parametric\-Mobius class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Parametric\-Mobius = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Parametric\-Mobius = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Radius (double )} -\/ Set/\-Get the radius of the Mobius strip.  
\item {\ttfamily double = obj.\-Get\-Radius ()} -\/ Set/\-Get the radius of the Mobius strip.  
\item {\ttfamily int = obj.\-Get\-Dimension ()} -\/ The Mobius strip.

This function performs the mapping $f(u,v) \rightarrow (x,y,x)$, returning it as Pt. It also returns the partial derivatives Du and Dv. $Pt = (x, y, z), Du = (dx/du, dy/du, dz/du), Dv = (dx/dv, dy/dv, dz/dv)$ . Then the normal is $N = Du X Dv$ .  
\item {\ttfamily obj.\-Evaluate (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ The Mobius strip.

This function performs the mapping $f(u,v) \rightarrow (x,y,x)$, returning it as Pt. It also returns the partial derivatives Du and Dv. $Pt = (x, y, z), Du = (dx/du, dy/du, dz/du), Dv = (dx/dv, dy/dv, dz/dv)$ . Then the normal is $N = Du X Dv$ .  
\item {\ttfamily double = obj.\-Evaluate\-Scalar (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ Calculate a user defined scalar using one or all of uvw, Pt, Duvw.

uvw are the parameters with Pt being the the cartesian point, Duvw are the derivatives of this point with respect to u, v and w. Pt, Du, Dv are obtained from Evaluate().

This function is only called if the Scalar\-Mode has the value vtk\-Parametric\-Function\-Source\-::\-S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D

If the user does not need to calculate a scalar, then the instantiated function should return zero.


\end{DoxyItemize}\hypertarget{vtkcommon_vtkparametricrandomhills}{}\section{vtk\-Parametric\-Random\-Hills}\label{vtkcommon_vtkparametricrandomhills}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Parametric\-Random\-Hills generates a surface covered with randomly placed hills.

For further information about this surface, please consult the technical description \char`\"{}\-Parametric surfaces\char`\"{} in \href{http://www.vtk.org/documents.php}{\tt http\-://www.\-vtk.\-org/documents.\-php} in the \char`\"{}\-V\-T\-K Technical Documents\char`\"{} section in the V\-Tk.\-org web pages.

.S\-E\-C\-T\-I\-O\-N Thanks Andrew Maclean \href{mailto:a.maclean@cas.edu.au}{\tt a.\-maclean@cas.\-edu.\-au} for creating and contributing the class.

To create an instance of class vtk\-Parametric\-Random\-Hills, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkParametricRandomHills
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Parametric\-Random\-Hills has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Parametric\-Random\-Hills class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Parametric\-Random\-Hills = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Parametric\-Random\-Hills = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Dimension ()} -\/ Construct a surface of random hills with the following parameters\-: Minimum\-U = -\/10, Maximum\-U = 10, Minimum\-V = -\/10, Maximum\-V = 10, Join\-U = 0, Join\-V = 0, Twist\-U = 0, Twist\-V = 0; Clockwise\-Ordering = 1, Derivatives\-Available = 0, Number of hills = 30, Variance of the hills 2.\-5 in both x-\/ and y-\/ directions, Scaling factor for the variances 1/3 in both x-\/ and y-\/ directions, Amplitude of each hill = 1, Scaling factor for the amplitude = 1/3, Random\-Seed = 1, Allow\-Random\-Generation = 1.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Hills (int )} -\/ Set/\-Get the number of hills. Default is 30.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Hills ()} -\/ Set/\-Get the number of hills. Default is 30.  
\item {\ttfamily obj.\-Set\-Hill\-X\-Variance (double )} -\/ Set/\-Get the hill variance in the x-\/direction. Default is 2.\-5.  
\item {\ttfamily double = obj.\-Get\-Hill\-X\-Variance ()} -\/ Set/\-Get the hill variance in the x-\/direction. Default is 2.\-5.  
\item {\ttfamily obj.\-Set\-Hill\-Y\-Variance (double )} -\/ Set/\-Get the hill variance in the y-\/direction. Default is 2.\-5.  
\item {\ttfamily double = obj.\-Get\-Hill\-Y\-Variance ()} -\/ Set/\-Get the hill variance in the y-\/direction. Default is 2.\-5.  
\item {\ttfamily obj.\-Set\-Hill\-Amplitude (double )} -\/ Set/\-Get the hill amplitude (height). Default is 2.  
\item {\ttfamily double = obj.\-Get\-Hill\-Amplitude ()} -\/ Set/\-Get the hill amplitude (height). Default is 2.  
\item {\ttfamily obj.\-Set\-Random\-Seed (int )} -\/ Set/\-Get the Seed for the random number generator, a value of 1 will initialize the random number generator, a negative value will initialize it with the system time. Default is 1.  
\item {\ttfamily int = obj.\-Get\-Random\-Seed ()} -\/ Set/\-Get the Seed for the random number generator, a value of 1 will initialize the random number generator, a negative value will initialize it with the system time. Default is 1.  
\item {\ttfamily obj.\-Set\-Allow\-Random\-Generation (int )} -\/ Set/\-Get the random generation flag. A value of 0 will disable the generation of random hills on the surface. This allows a reproducible shape to be generated. Any other value means that the generation of the hills will be done randomly. Default is 1.  
\item {\ttfamily int = obj.\-Get\-Allow\-Random\-Generation ()} -\/ Set/\-Get the random generation flag. A value of 0 will disable the generation of random hills on the surface. This allows a reproducible shape to be generated. Any other value means that the generation of the hills will be done randomly. Default is 1.  
\item {\ttfamily obj.\-Allow\-Random\-Generation\-On ()} -\/ Set/\-Get the random generation flag. A value of 0 will disable the generation of random hills on the surface. This allows a reproducible shape to be generated. Any other value means that the generation of the hills will be done randomly. Default is 1.  
\item {\ttfamily obj.\-Allow\-Random\-Generation\-Off ()} -\/ Set/\-Get the random generation flag. A value of 0 will disable the generation of random hills on the surface. This allows a reproducible shape to be generated. Any other value means that the generation of the hills will be done randomly. Default is 1.  
\item {\ttfamily obj.\-Set\-X\-Variance\-Scale\-Factor (double )} -\/ Set/\-Get the scaling factor for the variance in the x-\/direction. Default is 1/3.  
\item {\ttfamily double = obj.\-Get\-X\-Variance\-Scale\-Factor ()} -\/ Set/\-Get the scaling factor for the variance in the x-\/direction. Default is 1/3.  
\item {\ttfamily obj.\-Set\-Y\-Variance\-Scale\-Factor (double )} -\/ Set/\-Get the scaling factor for the variance in the y-\/direction. Default is 1/3.  
\item {\ttfamily double = obj.\-Get\-Y\-Variance\-Scale\-Factor ()} -\/ Set/\-Get the scaling factor for the variance in the y-\/direction. Default is 1/3.  
\item {\ttfamily obj.\-Set\-Amplitude\-Scale\-Factor (double )} -\/ Set/\-Get the scaling factor for the amplitude. Default is 1/3.  
\item {\ttfamily double = obj.\-Get\-Amplitude\-Scale\-Factor ()} -\/ Set/\-Get the scaling factor for the amplitude. Default is 1/3.  
\item {\ttfamily obj.\-Generate\-The\-Hills (void )} -\/ Generate the centers of the hills, their standard deviations and their amplitudes. This function creates a series of vectors representing the u, v coordinates of each hill, its variance in the u, v directions and the amplitude.

N\-O\-T\-E\-: This function must be called whenever any of the parameters are changed.  
\item {\ttfamily obj.\-Evaluate (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ Construct a terrain consisting of randomly placed hills on a surface.

It is assumed that the function Generate\-The\-Hills() has been executed to build the vectors of coordinates required to generate the point Pt. Pt represents the sum of all the amplitudes over the space.

This function performs the mapping $f(u,v) \rightarrow (x,y,x)$, returning it as Pt. It also returns the partial derivatives Du and Dv. $Pt = (x, y, z), Du = (dx/du, dy/du, dz/du), Dv = (dx/dv, dy/dv, dz/dv)$ . Then the normal is $N = Du X Dv$ .  
\item {\ttfamily double = obj.\-Evaluate\-Scalar (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ Calculate a user defined scalar using one or all of uvw, Pt, Duvw.

uvw are the parameters with Pt being the the Cartesian point, Duvw are the derivatives of this point with respect to u, v and w. Pt, Duvw are obtained from Evaluate().

This function is only called if the Scalar\-Mode has the value vtk\-Parametric\-Function\-Source\-::\-S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D

If the user does not need to calculate a scalar, then the instantiated function should return zero.


\end{DoxyItemize}\hypertarget{vtkcommon_vtkparametricroman}{}\section{vtk\-Parametric\-Roman}\label{vtkcommon_vtkparametricroman}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Parametric\-Roman generates Steiner's Roman Surface.

For further information about this surface, please consult the technical description \char`\"{}\-Parametric surfaces\char`\"{} in \href{http://www.vtk.org/documents.php}{\tt http\-://www.\-vtk.\-org/documents.\-php} in the \char`\"{}\-V\-T\-K Technical Documents\char`\"{} section in the V\-Tk.\-org web pages.

.S\-E\-C\-T\-I\-O\-N Thanks Andrew Maclean \href{mailto:a.maclean@cas.edu.au}{\tt a.\-maclean@cas.\-edu.\-au} for creating and contributing the class.

To create an instance of class vtk\-Parametric\-Roman, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkParametricRoman
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Parametric\-Roman has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Parametric\-Roman class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Parametric\-Roman = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Parametric\-Roman = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Dimension ()} -\/ Construct Steiner's Roman Surface with the following parameters\-: Minimum\-U = 0, Maximum\-U = Pi, Minimum\-V = 0, Maximum\-V = Pi, Join\-U = 1, Join\-V = 1, Twist\-U = 1, Twist\-V = 0; Clockwise\-Ordering = 1, Derivatives\-Available = 1, Radius = 1  
\item {\ttfamily obj.\-Set\-Radius (double )} -\/ Set/\-Get the radius.  
\item {\ttfamily double = obj.\-Get\-Radius ()} -\/ Set/\-Get the radius.  
\item {\ttfamily obj.\-Evaluate (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ Steiner's Roman Surface

This function performs the mapping $f(u,v) \rightarrow (x,y,x)$, returning it as Pt. It also returns the partial derivatives Du and Dv. $Pt = (x, y, z), Du = (dx/du, dy/du, dz/du), Dv = (dx/dv, dy/dv, dz/dv)$ . Then the normal is $N = Du X Dv$ .  
\item {\ttfamily double = obj.\-Evaluate\-Scalar (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ Calculate a user defined scalar using one or all of uvw, Pt, Duvw.

uvw are the parameters with Pt being the the Cartesian point, Duvw are the derivatives of this point with respect to u, v and w. Pt, Duvw are obtained from Evaluate().

This function is only called if the Scalar\-Mode has the value vtk\-Parametric\-Function\-Source\-::\-S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D

If the user does not need to calculate a scalar, then the instantiated function should return zero.


\end{DoxyItemize}\hypertarget{vtkcommon_vtkparametricsuperellipsoid}{}\section{vtk\-Parametric\-Super\-Ellipsoid}\label{vtkcommon_vtkparametricsuperellipsoid}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Parametric\-Super\-Ellipsoid generates a superellipsoid. A superellipsoid is a versatile primitive that is controlled by two parameters n1 and n2. As special cases it can represent a sphere, square box, and closed cylindrical can.

For further information about this surface, please consult the technical description \char`\"{}\-Parametric surfaces\char`\"{} in \href{http://www.vtk.org/documents.php}{\tt http\-://www.\-vtk.\-org/documents.\-php} in the \char`\"{}\-V\-T\-K Technical Documents\char`\"{} section in the V\-Tk.\-org web pages.

Also see\-: \href{http://astronomy.swin.edu.au/~pbourke/surfaces/}{\tt http\-://astronomy.\-swin.\-edu.\-au/$\sim$pbourke/surfaces/}

To create an instance of class vtk\-Parametric\-Super\-Ellipsoid, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkParametricSuperEllipsoid
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Parametric\-Super\-Ellipsoid has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Parametric\-Super\-Ellipsoid class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Parametric\-Super\-Ellipsoid = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Parametric\-Super\-Ellipsoid = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Dimension ()} -\/ Set/\-Get the scaling factor for the x-\/axis. Default = 1.  
\item {\ttfamily obj.\-Set\-X\-Radius (double )} -\/ Set/\-Get the scaling factor for the x-\/axis. Default = 1.  
\item {\ttfamily double = obj.\-Get\-X\-Radius ()} -\/ Set/\-Get the scaling factor for the x-\/axis. Default = 1.  
\item {\ttfamily obj.\-Set\-Y\-Radius (double )} -\/ Set/\-Get the scaling factor for the y-\/axis. Default = 1.  
\item {\ttfamily double = obj.\-Get\-Y\-Radius ()} -\/ Set/\-Get the scaling factor for the y-\/axis. Default = 1.  
\item {\ttfamily obj.\-Set\-Z\-Radius (double )} -\/ Set/\-Get the scaling factor for the z-\/axis. Default = 1.  
\item {\ttfamily double = obj.\-Get\-Z\-Radius ()} -\/ Set/\-Get the scaling factor for the z-\/axis. Default = 1.  
\item {\ttfamily obj.\-Set\-N1 (double )} -\/ Set/\-Get the \char`\"{}squareness\char`\"{} parameter in the z axis. Default = 1.  
\item {\ttfamily double = obj.\-Get\-N1 ()} -\/ Set/\-Get the \char`\"{}squareness\char`\"{} parameter in the z axis. Default = 1.  
\item {\ttfamily obj.\-Set\-N2 (double )} -\/ Set/\-Get the \char`\"{}squareness\char`\"{} parameter in the x-\/y plane. Default = 1.  
\item {\ttfamily double = obj.\-Get\-N2 ()} -\/ Set/\-Get the \char`\"{}squareness\char`\"{} parameter in the x-\/y plane. Default = 1.  
\item {\ttfamily obj.\-Evaluate (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ A superellipsoid.

This function performs the mapping $f(u,v) \rightarrow (x,y,x)$, returning it as Pt. It also returns the partial derivatives Du and Dv. $Pt = (x, y, z), Du = (dx/du, dy/du, dz/du), Dv = (dx/dv, dy/dv, dz/dv)$ . Then the normal is $N = Du X Dv$ .  
\item {\ttfamily double = obj.\-Evaluate\-Scalar (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ Calculate a user defined scalar using one or all of uvw, Pt, Duvw.

uvw are the parameters with Pt being the the cartesian point, Duvw are the derivatives of this point with respect to u, v and w. Pt, Duvw are obtained from Evaluate().

This function is only called if the Scalar\-Mode has the value vtk\-Parametric\-Function\-Source\-::\-S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D

If the user does not need to calculate a scalar, then the instantiated function should return zero.


\end{DoxyItemize}\hypertarget{vtkcommon_vtkparametricsupertoroid}{}\section{vtk\-Parametric\-Super\-Toroid}\label{vtkcommon_vtkparametricsupertoroid}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Parametric\-Super\-Toroid generates a supertoroid. Essentially a supertoroid is a torus with the sine and cosine terms raised to a power. A supertoroid is a versatile primitive that is controlled by four parameters r0, r1, n1 and n2. r0, r1 determine the type of torus whilst the value of n1 determines the shape of the torus ring and n2 determines the shape of the cross section of the ring. It is the different values of these powers which give rise to a family of 3\-D shapes that are all basically toroidal in shape.

For further information about this surface, please consult the technical description \char`\"{}\-Parametric surfaces\char`\"{} in \href{http://www.vtk.org/documents.php}{\tt http\-://www.\-vtk.\-org/documents.\-php} in the \char`\"{}\-V\-T\-K Technical Documents\char`\"{} section in the V\-Tk.\-org web pages.

Also see\-: \href{http://astronomy.swin.edu.au/~pbourke/surfaces/}{\tt http\-://astronomy.\-swin.\-edu.\-au/$\sim$pbourke/surfaces/}.

To create an instance of class vtk\-Parametric\-Super\-Toroid, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkParametricSuperToroid
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Parametric\-Super\-Toroid has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Parametric\-Super\-Toroid class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Parametric\-Super\-Toroid = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Parametric\-Super\-Toroid = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Dimension ()} -\/ Set/\-Get the radius from the center to the middle of the ring of the supertoroid. Default = 1.  
\item {\ttfamily obj.\-Set\-Ring\-Radius (double )} -\/ Set/\-Get the radius from the center to the middle of the ring of the supertoroid. Default = 1.  
\item {\ttfamily double = obj.\-Get\-Ring\-Radius ()} -\/ Set/\-Get the radius from the center to the middle of the ring of the supertoroid. Default = 1.  
\item {\ttfamily obj.\-Set\-Cross\-Section\-Radius (double )} -\/ Set/\-Get the radius of the cross section of ring of the supertoroid. Default = 0.\-5.  
\item {\ttfamily double = obj.\-Get\-Cross\-Section\-Radius ()} -\/ Set/\-Get the radius of the cross section of ring of the supertoroid. Default = 0.\-5.  
\item {\ttfamily obj.\-Set\-X\-Radius (double )} -\/ Set/\-Get the scaling factor for the x-\/axis. Default = 1.  
\item {\ttfamily double = obj.\-Get\-X\-Radius ()} -\/ Set/\-Get the scaling factor for the x-\/axis. Default = 1.  
\item {\ttfamily obj.\-Set\-Y\-Radius (double )} -\/ Set/\-Get the scaling factor for the y-\/axis. Default = 1.  
\item {\ttfamily double = obj.\-Get\-Y\-Radius ()} -\/ Set/\-Get the scaling factor for the y-\/axis. Default = 1.  
\item {\ttfamily obj.\-Set\-Z\-Radius (double )} -\/ Set/\-Get the scaling factor for the z-\/axis. Default = 1.  
\item {\ttfamily double = obj.\-Get\-Z\-Radius ()} -\/ Set/\-Get the scaling factor for the z-\/axis. Default = 1.  
\item {\ttfamily obj.\-Set\-N1 (double )} -\/ Set/\-Get the shape of the torus ring. Default = 1.  
\item {\ttfamily double = obj.\-Get\-N1 ()} -\/ Set/\-Get the shape of the torus ring. Default = 1.  
\item {\ttfamily obj.\-Set\-N2 (double )} -\/ Set/\-Get the shape of the cross section of the ring. Default = 1.  
\item {\ttfamily double = obj.\-Get\-N2 ()} -\/ Set/\-Get the shape of the cross section of the ring. Default = 1.  
\item {\ttfamily obj.\-Evaluate (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ A supertoroid.

This function performs the mapping $f(u,v) \rightarrow (x,y,x)$, returning it as Pt. It also returns the partial derivatives Du and Dv. $Pt = (x, y, z), Du = (dx/du, dy/du, dz/du), Dv = (dx/dv, dy/dv, dz/dv)$ . Then the normal is $N = Du X Dv$ .  
\item {\ttfamily double = obj.\-Evaluate\-Scalar (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ Calculate a user defined scalar using one or all of uvw, Pt, Duvw.

uvw are the parameters with Pt being the the cartesian point, Duvw are the derivatives of this point with respect to u, v and w. Pt, Duvw are obtained from Evaluate().

This function is only called if the Scalar\-Mode has the value vtk\-Parametric\-Function\-Source\-::\-S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D

If the user does not need to calculate a scalar, then the instantiated function should return zero.


\end{DoxyItemize}\hypertarget{vtkcommon_vtkparametrictorus}{}\section{vtk\-Parametric\-Torus}\label{vtkcommon_vtkparametrictorus}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Parametric\-Torus generates a torus.

For further information about this surface, please consult the technical description \char`\"{}\-Parametric surfaces\char`\"{} in \href{http://www.vtk.org/documents.php}{\tt http\-://www.\-vtk.\-org/documents.\-php} in the \char`\"{}\-V\-T\-K Technical Documents\char`\"{} section in the V\-Tk.\-org web pages.

.S\-E\-C\-T\-I\-O\-N Thanks Andrew Maclean \href{mailto:a.maclean@cas.edu.au}{\tt a.\-maclean@cas.\-edu.\-au} for creating and contributing the class.

To create an instance of class vtk\-Parametric\-Torus, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkParametricTorus
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Parametric\-Torus has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Parametric\-Torus class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Parametric\-Torus = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Parametric\-Torus = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Ring\-Radius (double )} -\/ Set/\-Get the radius from the center to the middle of the ring of the torus. The default value is 1.\-0.  
\item {\ttfamily double = obj.\-Get\-Ring\-Radius ()} -\/ Set/\-Get the radius from the center to the middle of the ring of the torus. The default value is 1.\-0.  
\item {\ttfamily obj.\-Set\-Cross\-Section\-Radius (double )} -\/ Set/\-Get the radius of the cross section of ring of the torus. The default value is 0.\-5.  
\item {\ttfamily double = obj.\-Get\-Cross\-Section\-Radius ()} -\/ Set/\-Get the radius of the cross section of ring of the torus. The default value is 0.\-5.  
\item {\ttfamily int = obj.\-Get\-Dimension ()} -\/ A torus.

This function performs the mapping $f(u,v) \rightarrow (x,y,x)$, returning it as Pt. It also returns the partial derivatives Du and Dv. $Pt = (x, y, z), Du = (dx/du, dy/du, dz/du), Dv = (dx/dv, dy/dv, dz/dv)$. Then the normal is $N = Du X Dv$.  
\item {\ttfamily obj.\-Evaluate (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ A torus.

This function performs the mapping $f(u,v) \rightarrow (x,y,x)$, returning it as Pt. It also returns the partial derivatives Du and Dv. $Pt = (x, y, z), Du = (dx/du, dy/du, dz/du), Dv = (dx/dv, dy/dv, dz/dv)$. Then the normal is $N = Du X Dv$.  
\item {\ttfamily double = obj.\-Evaluate\-Scalar (double uvw\mbox{[}3\mbox{]}, double Pt\mbox{[}3\mbox{]}, double Duvw\mbox{[}9\mbox{]})} -\/ Calculate a user defined scalar using one or all of uvw, Pt, Duvw.

uvw are the parameters with Pt being the the Cartesian point, Duvw are the derivatives of this point with respect to u, v and w. Pt, Duvw are obtained from Evaluate().

This function is only called if the Scalar\-Mode has the value vtk\-Parametric\-Function\-Source\-::\-S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D

If the user does not need to calculate a scalar, then the instantiated function should return zero.


\end{DoxyItemize}\hypertarget{vtkcommon_vtkperspectivetransform}{}\section{vtk\-Perspective\-Transform}\label{vtkcommon_vtkperspectivetransform}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
A vtk\-Perspective\-Transform can be used to describe the full range of homogeneous transformations. It was designed in particular to describe a camera-\/view of a scene. 

The order in which you set up the display coordinates (via Adjust\-Z\-Buffer() and Adjust\-Viewport()), the projection (via Perspective(), Frustum(), or Ortho()) and the camera view (via Setup\-Camera()) are important. If the transform is in Pre\-Multiply mode, which is the default, set the Viewport and Z\-Buffer first, then the projection, and finally the camera view. Once the view is set up, the Translate and Rotate methods can be used to move the camera around in world coordinates. If the Oblique() or Stereo() methods are used, they should be called just before Setup\-Camera(). 

In Post\-Multiply mode, you must perform all transformations in the opposite order. This is necessary, for example, if you already have a perspective transformation set up but must adjust the viewport. Another example is if you have a view transformation, and wish to perform translations and rotations in the camera's coordinate system rather than in world coordinates. 

The Set\-Input and Concatenate methods can be used to create a transformation pipeline with vtk\-Perspective\-Transform. See vtk\-Transform for more information on the transformation pipeline.

To create an instance of class vtk\-Perspective\-Transform, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPerspectiveTransform
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Perspective\-Transform has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Perspective\-Transform class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Perspective\-Transform = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Perspective\-Transform = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Identity ()} -\/ Set this transformation to the identity transformation. If the transform has an Input, then the transformation will be reset so that it is the same as the Input.  
\item {\ttfamily obj.\-Inverse ()} -\/ Invert the transformation. This will also set a flag so that the transformation will use the inverse of its Input, if an Input has been set.  
\item {\ttfamily obj.\-Adjust\-Viewport (double old\-X\-Min, double old\-X\-Max, double old\-Y\-Min, double old\-Y\-Max, double new\-X\-Min, double new\-X\-Max, double new\-Y\-Min, double new\-Y\-Max)} -\/ Perform an adjustment to the viewport coordinates. By default Ortho, Frustum, and Perspective provide a window of (\mbox{[}-\/1,+1\mbox{]},\mbox{[}-\/1,+1\mbox{]}). In Pre\-Multiply mode, you call this method before calling Ortho, Frustum, or Perspective. In Post\-Multiply mode you can call it after. Note that if you must apply both Adjust\-Z\-Buffer and Adjust\-Viewport, it makes no difference which order you apply them in.  
\item {\ttfamily obj.\-Adjust\-Z\-Buffer (double old\-Near\-Z, double old\-Far\-Z, double new\-Near\-Z, double new\-Far\-Z)} -\/ Perform an adjustment to the Z-\/\-Buffer range that the near and far clipping planes map to. By default Ortho, Frustum, and Perspective map the near clipping plane to -\/1 and the far clipping plane to +1. In Pre\-Multiply mode, you call this method before calling Ortho, Frustum, or Perspective. In Post\-Multiply mode you can call it after.  
\item {\ttfamily obj.\-Ortho (double xmin, double xmax, double ymin, double ymax, double znear, double zfar)} -\/ Create an orthogonal projection matrix and concatenate it by the current transformation. The matrix maps \mbox{[}xmin,xmax\mbox{]}, \mbox{[}ymin,ymax\mbox{]}, \mbox{[}-\/znear,-\/zfar\mbox{]} to \mbox{[}-\/1,+1\mbox{]}, \mbox{[}-\/1,+1\mbox{]}, \mbox{[}+1,-\/1\mbox{]}.  
\item {\ttfamily obj.\-Frustum (double xmin, double xmax, double ymin, double ymax, double znear, double zfar)} -\/ Create an perspective projection matrix and concatenate it by the current transformation. The matrix maps a frustum with a back plane at -\/zfar and a front plane at -\/znear with extent \mbox{[}xmin,xmax\mbox{]},\mbox{[}ymin,ymax\mbox{]} to \mbox{[}-\/1,+1\mbox{]}, \mbox{[}-\/1,+1\mbox{]}, \mbox{[}+1,-\/1\mbox{]}.  
\item {\ttfamily obj.\-Perspective (double angle, double aspect, double znear, double zfar)} -\/ Create a perspective projection matrix by specifying the view angle (this angle is in the y direction), the aspect ratio, and the near and far clipping range. The projection matrix is concatenated with the current transformation. This method works via Frustum.  
\item {\ttfamily obj.\-Shear (double dxdz, double dydz, double zplane)} -\/ Create a shear transformation about a plane at distance z from the camera. The values dxdz (i.\-e. dx/dz) and dydz specify the amount of shear in the x and y directions. The 'zplane' specifies the distance from the camera to the plane at which the shear causes zero displacement. Generally you want this plane to be the focal plane. This transformation can be used in combination with Ortho to create an oblique projection. It can also be used in combination with Perspective to provide correct stereo views when the eye is at arbitrary but known positions relative to the center of a flat viewing screen.  
\item {\ttfamily obj.\-Stereo (double angle, double focaldistance)} -\/ Create a stereo shear matrix and concatenate it with the current transformation. This can be applied in conjunction with either a perspective transformation (via Frustum or Projection) or an orthographic projection. You must specify the distance from the camera plane to the focal plane, and the angle between the distance vector and the eye. The angle should be negative for the left eye, and positive for the right. This method works via Oblique.  
\item {\ttfamily obj.\-Setup\-Camera (double position\mbox{[}3\mbox{]}, double focalpoint\mbox{[}3\mbox{]}, double viewup\mbox{[}3\mbox{]})} -\/ Set a view transformation matrix for the camera (this matrix does not contain any perspective) and concatenate it with the current transformation.  
\item {\ttfamily obj.\-Setup\-Camera (double p0, double p1, double p2, double fp0, double fp1, double fp2, double vup0, double vup1, double vup2)}  
\item {\ttfamily obj.\-Translate (double x, double y, double z)} -\/ Create a translation matrix and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Translate (double x\mbox{[}3\mbox{]})} -\/ Create a translation matrix and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Translate (float x\mbox{[}3\mbox{]})} -\/ Create a translation matrix and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Rotate\-W\-X\-Y\-Z (double angle, double x, double y, double z)} -\/ Create a rotation matrix and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics. The angle is in degrees, and (x,y,z) specifies the axis that the rotation will be performed around.  
\item {\ttfamily obj.\-Rotate\-W\-X\-Y\-Z (double angle, double axis\mbox{[}3\mbox{]})} -\/ Create a rotation matrix and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics. The angle is in degrees, and (x,y,z) specifies the axis that the rotation will be performed around.  
\item {\ttfamily obj.\-Rotate\-W\-X\-Y\-Z (double angle, float axis\mbox{[}3\mbox{]})} -\/ Create a rotation matrix and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics. The angle is in degrees, and (x,y,z) specifies the axis that the rotation will be performed around.  
\item {\ttfamily obj.\-Rotate\-X (double angle)} -\/ Create a rotation matrix about the X, Y, or Z axis and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics. The angle is expressed in degrees.  
\item {\ttfamily obj.\-Rotate\-Y (double angle)} -\/ Create a rotation matrix about the X, Y, or Z axis and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics. The angle is expressed in degrees.  
\item {\ttfamily obj.\-Rotate\-Z (double angle)} -\/ Create a rotation matrix about the X, Y, or Z axis and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics. The angle is expressed in degrees.  
\item {\ttfamily obj.\-Scale (double x, double y, double z)} -\/ Create a scale matrix (i.\-e. set the diagonal elements to x, y, z) and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Scale (double s\mbox{[}3\mbox{]})} -\/ Create a scale matrix (i.\-e. set the diagonal elements to x, y, z) and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Scale (float s\mbox{[}3\mbox{]})} -\/ Create a scale matrix (i.\-e. set the diagonal elements to x, y, z) and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Set\-Matrix (vtk\-Matrix4x4 matrix)} -\/ Set the current matrix directly. This actually calls Identity(), followed by Concatenate(matrix).  
\item {\ttfamily obj.\-Set\-Matrix (double elements\mbox{[}16\mbox{]})} -\/ Set the current matrix directly. This actually calls Identity(), followed by Concatenate(matrix).  
\item {\ttfamily obj.\-Concatenate (vtk\-Matrix4x4 matrix)} -\/ Concatenates the matrix with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Concatenate (double elements\mbox{[}16\mbox{]})} -\/ Concatenates the matrix with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Concatenate (vtk\-Homogeneous\-Transform transform)} -\/ Concatenate the specified transform with the current transformation according to Pre\-Multiply or Post\-Multiply semantics. The concatenation is pipelined, meaning that if any of the transformations are changed, even after Concatenate() is called, those changes will be reflected when you call Transform\-Point().  
\item {\ttfamily obj.\-Pre\-Multiply ()} -\/ Sets the internal state of the transform to Pre\-Multiply. All subsequent operations will occur before those already represented in the current transformation. In homogeneous matrix notation, M = M$\ast$\-A where M is the current transformation matrix and A is the applied matrix. The default is Pre\-Multiply.  
\item {\ttfamily obj.\-Post\-Multiply ()} -\/ Sets the internal state of the transform to Post\-Multiply. All subsequent operations will occur after those already represented in the current transformation. In homogeneous matrix notation, M = A$\ast$\-M where M is the current transformation matrix and A is the applied matrix. The default is Pre\-Multiply.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Concatenated\-Transforms ()} -\/ Get the total number of transformations that are linked into this one via Concatenate() operations or via Set\-Input().  
\item {\ttfamily vtk\-Homogeneous\-Transform = obj.\-Get\-Concatenated\-Transform (int i)} -\/ Set the input for this transformation. This will be used as the base transformation if it is set. This method allows you to build a transform pipeline\-: if the input is modified, then this transformation will automatically update accordingly. Note that the Inverse\-Flag, controlled via Inverse(), determines whether this transformation will use the Input or the inverse of the Input.  
\item {\ttfamily obj.\-Set\-Input (vtk\-Homogeneous\-Transform input)} -\/ Set the input for this transformation. This will be used as the base transformation if it is set. This method allows you to build a transform pipeline\-: if the input is modified, then this transformation will automatically update accordingly. Note that the Inverse\-Flag, controlled via Inverse(), determines whether this transformation will use the Input or the inverse of the Input.  
\item {\ttfamily vtk\-Homogeneous\-Transform = obj.\-Get\-Input ()} -\/ Set the input for this transformation. This will be used as the base transformation if it is set. This method allows you to build a transform pipeline\-: if the input is modified, then this transformation will automatically update accordingly. Note that the Inverse\-Flag, controlled via Inverse(), determines whether this transformation will use the Input or the inverse of the Input.  
\item {\ttfamily int = obj.\-Get\-Inverse\-Flag ()} -\/ Get the inverse flag of the transformation. This controls whether it is the Input or the inverse of the Input that is used as the base transformation. The Inverse\-Flag is flipped every time Inverse() is called. The Inverse\-Flag is off when a transform is first created.  
\item {\ttfamily obj.\-Push ()} -\/ Pushes the current transformation onto the transformation stack.  
\item {\ttfamily obj.\-Pop ()} -\/ Deletes the transformation on the top of the stack and sets the top to the next transformation on the stack.  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Make\-Transform ()} -\/ Make a new transform of the same type -- you are responsible for deleting the transform when you are done with it.  
\item {\ttfamily int = obj.\-Circuit\-Check (vtk\-Abstract\-Transform transform)} -\/ Check for self-\/reference. Will return true if concatenating with the specified transform, setting it to be our inverse, or setting it to be our input will create a circular reference. Circuit\-Check is automatically called by Set\-Input(), Set\-Inverse(), and Concatenate(vtk\-X\-Transform $\ast$). Avoid using this function, it is experimental.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Override Get\-M\-Time to account for input and concatenation.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkplane}{}\section{vtk\-Plane}\label{vtkcommon_vtkplane}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Plane provides methods for various plane computations. These include projecting points onto a plane, evaluating the plane equation, and returning plane normal. vtk\-Plane is a concrete implementation of the abstract class vtk\-Implicit\-Function.

To create an instance of class vtk\-Plane, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPlane
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Plane has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Plane class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Plane = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Plane = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily double = obj.\-Evaluate\-Function (double x\mbox{[}3\mbox{]})}  
\item {\ttfamily double = obj.\-Evaluate\-Function (double x, double y, double z)}  
\item {\ttfamily obj.\-Evaluate\-Gradient (double x\mbox{[}3\mbox{]}, double g\mbox{[}3\mbox{]})}  
\item {\ttfamily obj.\-Set\-Normal (double , double , double )} -\/ Set/get plane normal. Plane is defined by point and normal.  
\item {\ttfamily obj.\-Set\-Normal (double a\mbox{[}3\mbox{]})} -\/ Set/get plane normal. Plane is defined by point and normal.  
\item {\ttfamily double = obj. Get\-Normal ()} -\/ Set/get plane normal. Plane is defined by point and normal.  
\item {\ttfamily obj.\-Set\-Origin (double , double , double )} -\/ Set/get point through which plane passes. Plane is defined by point and normal.  
\item {\ttfamily obj.\-Set\-Origin (double a\mbox{[}3\mbox{]})} -\/ Set/get point through which plane passes. Plane is defined by point and normal.  
\item {\ttfamily double = obj. Get\-Origin ()} -\/ Set/get point through which plane passes. Plane is defined by point and normal.  
\item {\ttfamily obj.\-Push (double distance)} -\/ Translate the plane in the direction of the normal by the distance specified. Negative values move the plane in the opposite direction.  
\item {\ttfamily obj.\-Project\-Point (double x\mbox{[}3\mbox{]}, double xproj\mbox{[}3\mbox{]})}  
\item {\ttfamily obj.\-Generalized\-Project\-Point (double x\mbox{[}3\mbox{]}, double xproj\mbox{[}3\mbox{]})}  
\item {\ttfamily double = obj.\-Distance\-To\-Plane (double x\mbox{[}3\mbox{]})} -\/ Return the distance of a point x to a plane defined by n(x-\/p0) = 0. The normal n\mbox{[}3\mbox{]} must be magnitude=1.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkplanecollection}{}\section{vtk\-Plane\-Collection}\label{vtkcommon_vtkplanecollection}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Plane\-Collection is an object that creates and manipulates lists of objects of type vtk\-Plane.

To create an instance of class vtk\-Plane\-Collection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPlaneCollection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Plane\-Collection has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Plane\-Collection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Plane\-Collection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Plane\-Collection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Item (vtk\-Plane )} -\/ Add a plane to the list.  
\item {\ttfamily vtk\-Plane = obj.\-Get\-Next\-Item ()} -\/ Get the next plane in the list.  
\item {\ttfamily vtk\-Plane = obj.\-Get\-Item (int i)} -\/ Get the ith plane in the list.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkplanes}{}\section{vtk\-Planes}\label{vtkcommon_vtkplanes}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Planes computes the implicit function and function gradient for a set of planes. The planes must define a convex space.

The function value is the closest first order distance of a point to the convex region defined by the planes. The function gradient is the plane normal at the function value. Note that the normals must point outside of the convex region. Thus, a negative function value means that a point is inside the convex region.

There are several methods to define the set of planes. The most general is to supply an instance of vtk\-Points and an instance of vtk\-Data\-Array. (The points define a point on the plane, and the normals corresponding plane normals.) Two other specialized ways are to 1) supply six planes defining the view frustrum of a camera, and 2) provide a bounding box.

To create an instance of class vtk\-Planes, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPlanes
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Planes has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Planes class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Planes = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Planes = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily double = obj.\-Evaluate\-Function (double x\mbox{[}3\mbox{]})}  
\item {\ttfamily double = obj.\-Evaluate\-Function (double x, double y, double z)}  
\item {\ttfamily obj.\-Evaluate\-Gradient (double x\mbox{[}3\mbox{]}, double n\mbox{[}3\mbox{]})}  
\item {\ttfamily obj.\-Set\-Points (vtk\-Points )} -\/ Specify a list of points defining points through which the planes pass.  
\item {\ttfamily vtk\-Points = obj.\-Get\-Points ()} -\/ Specify a list of points defining points through which the planes pass.  
\item {\ttfamily obj.\-Set\-Normals (vtk\-Data\-Array normals)} -\/ Specify a list of normal vectors for the planes. There is a one-\/to-\/one correspondence between plane points and plane normals.  
\item {\ttfamily vtk\-Data\-Array = obj.\-Get\-Normals ()} -\/ Specify a list of normal vectors for the planes. There is a one-\/to-\/one correspondence between plane points and plane normals.  
\item {\ttfamily obj.\-Set\-Frustum\-Planes (double planes\mbox{[}24\mbox{]})} -\/ An alternative method to specify six planes defined by the camera view frustrum. See vtk\-Camera\-::\-Get\-Frustum\-Planes() documentation.  
\item {\ttfamily obj.\-Set\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ An alternative method to specify six planes defined by a bounding box. The bounding box is a six-\/vector defined as (xmin,xmax,ymin,ymax,zmin,zmax). It defines six planes orthogonal to the x-\/y-\/z coordinate axes.  
\item {\ttfamily obj.\-Set\-Bounds (double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)} -\/ An alternative method to specify six planes defined by a bounding box. The bounding box is a six-\/vector defined as (xmin,xmax,ymin,ymax,zmin,zmax). It defines six planes orthogonal to the x-\/y-\/z coordinate axes.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Planes ()} -\/ Return the number of planes in the set of planes.  
\item {\ttfamily vtk\-Plane = obj.\-Get\-Plane (int i)} -\/ Create and return a pointer to a vtk\-Plane object at the ith position. Asking for a plane outside the allowable range returns N\-U\-L\-L. This method always returns the same object. Use Get\-Plane(int i, vtk\-Plane $\ast$plane) instead  
\item {\ttfamily obj.\-Get\-Plane (int i, vtk\-Plane plane)} -\/ Create and return a pointer to a vtk\-Plane object at the ith position. Asking for a plane outside the allowable range returns N\-U\-L\-L. This method always returns the same object. Use Get\-Plane(int i, vtk\-Plane $\ast$plane) instead  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkpoints}{}\section{vtk\-Points}\label{vtkcommon_vtkpoints}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Points represents 3\-D points. The data model for vtk\-Points is an array of vx-\/vy-\/vz triplets accessible by (point or cell) id.

To create an instance of class vtk\-Points, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPoints
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Points has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Points class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Points = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Points = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Allocate (vtk\-Id\-Type sz, vtk\-Id\-Type ext)} -\/ Allocate initial memory size.  
\item {\ttfamily obj.\-Initialize ()} -\/ Return object to instantiated state.  
\item {\ttfamily obj.\-Set\-Data (vtk\-Data\-Array )} -\/ Set/\-Get the underlying data array. This function must be implemented in a concrete subclass to check for consistency. (The tuple size must match the type of data. For example, 3-\/tuple data array can be assigned to a vector, normal, or points object, but not a tensor object, which has a tuple dimension of 9. Scalars, on the other hand, can have tuple dimension from 1-\/4, depending on the type of scalar.)  
\item {\ttfamily vtk\-Data\-Array = obj.\-Get\-Data ()} -\/ Set/\-Get the underlying data array. This function must be implemented in a concrete subclass to check for consistency. (The tuple size must match the type of data. For example, 3-\/tuple data array can be assigned to a vector, normal, or points object, but not a tensor object, which has a tuple dimension of 9. Scalars, on the other hand, can have tuple dimension from 1-\/4, depending on the type of scalar.)  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()} -\/ Return the underlying data type. An integer indicating data type is returned as specified in vtk\-Set\-Get.\-h.  
\item {\ttfamily obj.\-Set\-Data\-Type (int data\-Type)} -\/ Specify the underlying data type of the object.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Bit ()} -\/ Specify the underlying data type of the object.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Char ()} -\/ Specify the underlying data type of the object.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Unsigned\-Char ()} -\/ Specify the underlying data type of the object.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Short ()} -\/ Specify the underlying data type of the object.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Unsigned\-Short ()} -\/ Specify the underlying data type of the object.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Int ()} -\/ Specify the underlying data type of the object.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Unsigned\-Int ()} -\/ Specify the underlying data type of the object.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Long ()} -\/ Specify the underlying data type of the object.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Unsigned\-Long ()} -\/ Specify the underlying data type of the object.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Float ()} -\/ Specify the underlying data type of the object.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Double ()} -\/ Specify the underlying data type of the object.  
\item {\ttfamily obj.\-Squeeze ()} -\/ Reclaim any extra memory.  
\item {\ttfamily obj.\-Reset ()} -\/ Make object look empty but do not delete memory.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Points ad)} -\/ Different ways to copy data. Shallow copy does reference count (i.\-e., assigns pointers and updates reference count); deep copy runs through entire data array assigning values.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Points ad)} -\/ Different ways to copy data. Shallow copy does reference count (i.\-e., assigns pointers and updates reference count); deep copy runs through entire data array assigning values.  
\item {\ttfamily long = obj.\-Get\-Actual\-Memory\-Size ()} -\/ Return the memory in kilobytes consumed by this attribute data. Used to support streaming and reading/writing data. The value returned is guaranteed to be greater than or equal to the memory required to actually represent the data represented by this object. The information returned is valid only after the pipeline has been updated.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Points ()} -\/ Return number of points in array.  
\item {\ttfamily double = obj.\-Get\-Point (vtk\-Id\-Type id)} -\/ Return a pointer to a double point x\mbox{[}3\mbox{]} for a specific id. W\-A\-R\-N\-I\-N\-G\-: Just don't use this error-\/prone method, the returned pointer and its values are only valid as long as another method invocation is not performed. Prefer Get\-Point() with the return value in argument.  
\item {\ttfamily obj.\-Get\-Point (vtk\-Id\-Type id, double x\mbox{[}3\mbox{]})} -\/ Copy point components into user provided array v\mbox{[}3\mbox{]} for specified id.  
\item {\ttfamily obj.\-Set\-Point (vtk\-Id\-Type id, float x\mbox{[}3\mbox{]})} -\/ Insert point into object. No range checking performed (fast!). Make sure you use Set\-Number\-Of\-Points() to allocate memory prior to using Set\-Point().  
\item {\ttfamily obj.\-Set\-Point (vtk\-Id\-Type id, double x\mbox{[}3\mbox{]})} -\/ Insert point into object. No range checking performed (fast!). Make sure you use Set\-Number\-Of\-Points() to allocate memory prior to using Set\-Point().  
\item {\ttfamily obj.\-Set\-Point (vtk\-Id\-Type id, double x, double y, double z)} -\/ Insert point into object. No range checking performed (fast!). Make sure you use Set\-Number\-Of\-Points() to allocate memory prior to using Set\-Point().  
\item {\ttfamily obj.\-Insert\-Point (vtk\-Id\-Type id, float x\mbox{[}3\mbox{]})} -\/ Insert point into object. Range checking performed and memory allocated as necessary.  
\item {\ttfamily obj.\-Insert\-Point (vtk\-Id\-Type id, double x\mbox{[}3\mbox{]})} -\/ Insert point into object. Range checking performed and memory allocated as necessary.  
\item {\ttfamily obj.\-Insert\-Point (vtk\-Id\-Type id, double x, double y, double z)} -\/ Insert point into object. Range checking performed and memory allocated as necessary.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Point (float x\mbox{[}3\mbox{]})} -\/ Insert point into next available slot. Returns id of slot.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Point (double x\mbox{[}3\mbox{]})} -\/ Insert point into next available slot. Returns id of slot.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Point (double x, double y, double z)} -\/ Insert point into next available slot. Returns id of slot.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Points (vtk\-Id\-Type number)} -\/ Specify the number of points for this object to hold. Does an allocation as well as setting the Max\-Id ivar. Used in conjunction with Set\-Point() method for fast insertion.  
\item {\ttfamily obj.\-Get\-Points (vtk\-Id\-List pt\-Id, vtk\-Points fp)} -\/ Given a list of pt ids, return an array of points.  
\item {\ttfamily obj.\-Compute\-Bounds ()} -\/ Determine (xmin,xmax, ymin,ymax, zmin,zmax) bounds of points.  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Return the bounds of the points.  
\item {\ttfamily obj.\-Get\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Return the bounds of the points.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkpoints2d}{}\section{vtk\-Points2\-D}\label{vtkcommon_vtkpoints2d}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Points2\-D represents 2\-D points. The data model for vtk\-Points2\-D is an array of vx-\/vy doublets accessible by (point or cell) id.

To create an instance of class vtk\-Points2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPoints2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Points2\-D has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Points2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Points2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Points2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Allocate (vtk\-Id\-Type sz, vtk\-Id\-Type ext)} -\/ Allocate initial memory size.  
\item {\ttfamily obj.\-Initialize ()} -\/ Return object to instantiated state.  
\item {\ttfamily obj.\-Set\-Data (vtk\-Data\-Array )} -\/ Set/\-Get the underlying data array. This function must be implemented in a concrete subclass to check for consistency. (The tuple size must match the type of data. For example, 3-\/tuple data array can be assigned to a vector, normal, or points object, but not a tensor object, which has a tuple dimension of 9. Scalars, on the other hand, can have tuple dimension from 1-\/4, depending on the type of scalar.)  
\item {\ttfamily vtk\-Data\-Array = obj.\-Get\-Data ()} -\/ Return the underlying data type. An integer indicating data type is returned as specified in vtk\-Set\-Get.\-h.  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()} -\/ Return the underlying data type. An integer indicating data type is returned as specified in vtk\-Set\-Get.\-h.  
\item {\ttfamily obj.\-Set\-Data\-Type (int data\-Type)} -\/ Specify the underlying data type of the object.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Bit ()} -\/ Specify the underlying data type of the object.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Char ()} -\/ Specify the underlying data type of the object.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Unsigned\-Char ()} -\/ Specify the underlying data type of the object.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Short ()} -\/ Specify the underlying data type of the object.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Unsigned\-Short ()} -\/ Specify the underlying data type of the object.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Int ()} -\/ Specify the underlying data type of the object.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Unsigned\-Int ()} -\/ Specify the underlying data type of the object.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Long ()} -\/ Specify the underlying data type of the object.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Unsigned\-Long ()} -\/ Specify the underlying data type of the object.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Float ()} -\/ Specify the underlying data type of the object.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Double ()} -\/ Return a void pointer. For image pipeline interface and other special pointer manipulation.  
\item {\ttfamily obj.\-Squeeze ()} -\/ Reclaim any extra memory.  
\item {\ttfamily obj.\-Reset ()} -\/ Make object look empty but do not delete memory.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Points2\-D ad)} -\/ Different ways to copy data. Shallow copy does reference count (i.\-e., assigns pointers and updates reference count); deep copy runs through entire data array assigning values.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Points2\-D ad)} -\/ Different ways to copy data. Shallow copy does reference count (i.\-e., assigns pointers and updates reference count); deep copy runs through entire data array assigning values.  
\item {\ttfamily long = obj.\-Get\-Actual\-Memory\-Size ()} -\/ Return the memory in kilobytes consumed by this attribute data. Used to support streaming and reading/writing data. The value returned is guaranteed to be greater than or equal to the memory required to actually represent the data represented by this object. The information returned is valid only after the pipeline has been updated.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Points ()} -\/ Return a pointer to a double point x\mbox{[}2\mbox{]} for a specific id. W\-A\-R\-N\-I\-N\-G\-: Just don't use this error-\/prone method, the returned pointer and its values are only valid as long as another method invocation is not performed. Prefer Get\-Point() with the return value in argument.  
\item {\ttfamily obj.\-Get\-Point (vtk\-Id\-Type id, double x\mbox{[}2\mbox{]})} -\/ Insert point into object. No range checking performed (fast!). Make sure you use Set\-Number\-Of\-Points() to allocate memory prior to using Set\-Point().  
\item {\ttfamily obj.\-Set\-Point (vtk\-Id\-Type id, float x\mbox{[}2\mbox{]})} -\/ Insert point into object. No range checking performed (fast!). Make sure you use Set\-Number\-Of\-Points() to allocate memory prior to using Set\-Point().  
\item {\ttfamily obj.\-Set\-Point (vtk\-Id\-Type id, double x\mbox{[}2\mbox{]})} -\/ Insert point into object. No range checking performed (fast!). Make sure you use Set\-Number\-Of\-Points() to allocate memory prior to using Set\-Point().  
\item {\ttfamily obj.\-Set\-Point (vtk\-Id\-Type id, double x, double y)} -\/ Insert point into object. No range checking performed (fast!). Make sure you use Set\-Number\-Of\-Points() to allocate memory prior to using Set\-Point().  
\item {\ttfamily obj.\-Insert\-Point (vtk\-Id\-Type id, float x\mbox{[}2\mbox{]})} -\/ Insert point into object. Range checking performed and memory allocated as necessary.  
\item {\ttfamily obj.\-Insert\-Point (vtk\-Id\-Type id, double x\mbox{[}2\mbox{]})} -\/ Insert point into object. Range checking performed and memory allocated as necessary.  
\item {\ttfamily obj.\-Insert\-Point (vtk\-Id\-Type id, double x, double y)} -\/ Insert point into object. Range checking performed and memory allocated as necessary.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Point (float x\mbox{[}2\mbox{]})} -\/ Insert point into next available slot. Returns id of slot.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Point (double x\mbox{[}2\mbox{]})} -\/ Insert point into next available slot. Returns id of slot.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Point (double x, double y)} -\/ Insert point into next available slot. Returns id of slot.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Points (vtk\-Id\-Type number)} -\/ Specify the number of points for this object to hold. Does an allocation as well as setting the Max\-Id ivar. Used in conjunction with Set\-Point() method for fast insertion.  
\item {\ttfamily obj.\-Get\-Points (vtk\-Id\-List pt\-Id, vtk\-Points2\-D fp)} -\/ Given a list of pt ids, return an array of points.  
\item {\ttfamily obj.\-Compute\-Bounds ()} -\/ Determine (xmin,xmax, ymin,ymax) bounds of points.  
\item {\ttfamily obj.\-Get\-Bounds (double bounds\mbox{[}4\mbox{]})} -\/ Return the bounds of the points.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkpolynomialsolversunivariate}{}\section{vtk\-Polynomial\-Solvers\-Univariate}\label{vtkcommon_vtkpolynomialsolversunivariate}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Polynomial\-Solvers\-Univariate provides solvers for univariate polynomial equations with real coefficients. The Tartaglia-\/\-Cardan and Ferrari solvers work on polynomials of fixed degree 3 and 4, respectively. The Lin-\/\-Bairstow and Sturm solvers work on polynomials of arbitrary degree. The Sturm solver is the most robust solver but only reports roots within an interval and does not report multiplicities. The Lin-\/\-Bairstow solver reports multiplicities.

For difficult polynomials, you may wish to use Filter\-Roots to eliminate some of the roots reported by the Sturm solver. Filter\-Roots evaluates the derivatives near each root to eliminate cases where a local minimum or maximum is close to zero.

.S\-E\-C\-T\-I\-O\-N Thanks Thanks to Philippe Pebay, Korben Rusek, David Thompson, and Maurice Rojas for implementing these solvers.

To create an instance of class vtk\-Polynomial\-Solvers\-Univariate, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPolynomialSolversUnivariate
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Polynomial\-Solvers\-Univariate has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Polynomial\-Solvers\-Univariate class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Polynomial\-Solvers\-Univariate = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Polynomial\-Solvers\-Univariate = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkpriorityqueue}{}\section{vtk\-Priority\-Queue}\label{vtkcommon_vtkpriorityqueue}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Priority\-Queue is a general object for creating and manipulating lists of object ids (e.\-g., point or cell ids). Object ids are sorted according to a user-\/specified priority, where entries at the top of the queue have the smallest values.

This implementation provides a feature beyond the usual ability to insert and retrieve (or pop) values from the queue. It is also possible to pop any item in the queue given its id number. This allows you to delete entries in the queue which can useful for reinserting an item into the queue.

To create an instance of class vtk\-Priority\-Queue, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPriorityQueue
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Priority\-Queue has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Priority\-Queue class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Priority\-Queue = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Priority\-Queue = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Allocate (vtk\-Id\-Type sz, vtk\-Id\-Type ext)} -\/ Allocate initial space for priority queue.  
\item {\ttfamily obj.\-Insert (double priority, vtk\-Id\-Type id)} -\/ Insert id with priority specified. The id is generally an index like a point id or cell id.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Pop (vtk\-Id\-Type location)} -\/ Same as above but simplified for easier wrapping into interpreted languages.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Peek (vtk\-Id\-Type location)} -\/ Peek into the queue without actually removing anything. Returns the id.  
\item {\ttfamily double = obj.\-Delete\-Id (vtk\-Id\-Type id)} -\/ Delete entry in queue with specified id. Returns priority value associated with that id; or V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E\-\_\-\-M\-A\-X if not in queue.  
\item {\ttfamily double = obj.\-Get\-Priority (vtk\-Id\-Type id)} -\/ Get the priority of an entry in the queue with specified id. Returns priority value of that id or V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E\-\_\-\-M\-A\-X if not in queue.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Items ()} -\/ Return the number of items in this queue.  
\item {\ttfamily obj.\-Reset ()} -\/ Empty the queue but without releasing memory. This avoids the overhead of memory allocation/deletion.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkprop}{}\section{vtk\-Prop}\label{vtkcommon_vtkprop}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Prop is an abstract superclass for any objects that can exist in a rendered scene (either 2\-D or 3\-D). Instances of vtk\-Prop may respond to various render methods (e.\-g., Render\-Opaque\-Geometry()). vtk\-Prop also defines the A\-P\-I for picking, L\-O\-D manipulation, and common instance variables that control visibility, picking, and dragging.

To create an instance of class vtk\-Prop, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkProp
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Prop has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Prop class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Prop = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Prop = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Get\-Actors (vtk\-Prop\-Collection )} -\/ For some exporters and other other operations we must be able to collect all the actors or volumes. These methods are used in that process.  
\item {\ttfamily obj.\-Get\-Actors2\-D (vtk\-Prop\-Collection )} -\/ For some exporters and other other operations we must be able to collect all the actors or volumes. These methods are used in that process.  
\item {\ttfamily obj.\-Get\-Volumes (vtk\-Prop\-Collection )} -\/ Set/\-Get visibility of this vtk\-Prop. Initial value is true.  
\item {\ttfamily obj.\-Set\-Visibility (int )} -\/ Set/\-Get visibility of this vtk\-Prop. Initial value is true.  
\item {\ttfamily int = obj.\-Get\-Visibility ()} -\/ Set/\-Get visibility of this vtk\-Prop. Initial value is true.  
\item {\ttfamily obj.\-Visibility\-On ()} -\/ Set/\-Get visibility of this vtk\-Prop. Initial value is true.  
\item {\ttfamily obj.\-Visibility\-Off ()} -\/ Set/\-Get visibility of this vtk\-Prop. Initial value is true.  
\item {\ttfamily obj.\-Set\-Pickable (int )} -\/ Set/\-Get the pickable instance variable. This determines if the vtk\-Prop can be picked (typically using the mouse). Also see dragable. Initial value is true.  
\item {\ttfamily int = obj.\-Get\-Pickable ()} -\/ Set/\-Get the pickable instance variable. This determines if the vtk\-Prop can be picked (typically using the mouse). Also see dragable. Initial value is true.  
\item {\ttfamily obj.\-Pickable\-On ()} -\/ Set/\-Get the pickable instance variable. This determines if the vtk\-Prop can be picked (typically using the mouse). Also see dragable. Initial value is true.  
\item {\ttfamily obj.\-Pickable\-Off ()} -\/ Set/\-Get the pickable instance variable. This determines if the vtk\-Prop can be picked (typically using the mouse). Also see dragable. Initial value is true.  
\item {\ttfamily obj.\-Pick ()} -\/ Method fires Pick\-Event if the prop is picked.  
\item {\ttfamily obj.\-Set\-Dragable (int )} -\/ Set/\-Get the value of the dragable instance variable. This determines if an Prop, once picked, can be dragged (translated) through space. This is typically done through an interactive mouse interface. This does not affect methods such as Set\-Position, which will continue to work. It is just intended to prevent some vtk\-Prop'ss from being dragged from within a user interface. Initial value is true.  
\item {\ttfamily int = obj.\-Get\-Dragable ()} -\/ Set/\-Get the value of the dragable instance variable. This determines if an Prop, once picked, can be dragged (translated) through space. This is typically done through an interactive mouse interface. This does not affect methods such as Set\-Position, which will continue to work. It is just intended to prevent some vtk\-Prop'ss from being dragged from within a user interface. Initial value is true.  
\item {\ttfamily obj.\-Dragable\-On ()} -\/ Set/\-Get the value of the dragable instance variable. This determines if an Prop, once picked, can be dragged (translated) through space. This is typically done through an interactive mouse interface. This does not affect methods such as Set\-Position, which will continue to work. It is just intended to prevent some vtk\-Prop'ss from being dragged from within a user interface. Initial value is true.  
\item {\ttfamily obj.\-Dragable\-Off ()} -\/ Set/\-Get the value of the dragable instance variable. This determines if an Prop, once picked, can be dragged (translated) through space. This is typically done through an interactive mouse interface. This does not affect methods such as Set\-Position, which will continue to work. It is just intended to prevent some vtk\-Prop'ss from being dragged from within a user interface. Initial value is true.  
\item {\ttfamily long = obj.\-Get\-Redraw\-M\-Time ()} -\/ In case the Visibility flag is true, tell if the bounds of this prop should be taken into account or ignored during the computation of other bounding boxes, like in vtk\-Renderer\-::\-Reset\-Camera(). Initial value is true.  
\item {\ttfamily obj.\-Set\-Use\-Bounds (bool )} -\/ In case the Visibility flag is true, tell if the bounds of this prop should be taken into account or ignored during the computation of other bounding boxes, like in vtk\-Renderer\-::\-Reset\-Camera(). Initial value is true.  
\item {\ttfamily bool = obj.\-Get\-Use\-Bounds ()} -\/ In case the Visibility flag is true, tell if the bounds of this prop should be taken into account or ignored during the computation of other bounding boxes, like in vtk\-Renderer\-::\-Reset\-Camera(). Initial value is true.  
\item {\ttfamily obj.\-Use\-Bounds\-On ()} -\/ In case the Visibility flag is true, tell if the bounds of this prop should be taken into account or ignored during the computation of other bounding boxes, like in vtk\-Renderer\-::\-Reset\-Camera(). Initial value is true.  
\item {\ttfamily obj.\-Use\-Bounds\-Off ()} -\/ In case the Visibility flag is true, tell if the bounds of this prop should be taken into account or ignored during the computation of other bounding boxes, like in vtk\-Renderer\-::\-Reset\-Camera(). Initial value is true.  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Shallow copy of this vtk\-Prop.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Shallow copy of this vtk\-Prop.  
\item {\ttfamily obj.\-Init\-Path\-Traversal ()} -\/ vtk\-Prop and its subclasses can be picked by subclasses of vtk\-Abstract\-Picker (e.\-g., vtk\-Prop\-Picker). The following methods interface with the picking classes and return \char`\"{}pick paths\char`\"{}. A pick path is a hierarchical, ordered list of props that form an assembly. Most often, when a vtk\-Prop is picked, its path consists of a single node (i.\-e., the prop). However, classes like vtk\-Assembly and vtk\-Prop\-Assembly can return more than one path, each path being several layers deep. (See vtk\-Assembly\-Path for more information.) To use these methods -\/ first invoke Init\-Path\-Traversal() followed by repeated calls to Get\-Next\-Path(). Get\-Next\-Path() returns a N\-U\-L\-L pointer when the list is exhausted.  
\item {\ttfamily vtk\-Assembly\-Path = obj.\-Get\-Next\-Path ()} -\/ vtk\-Prop and its subclasses can be picked by subclasses of vtk\-Abstract\-Picker (e.\-g., vtk\-Prop\-Picker). The following methods interface with the picking classes and return \char`\"{}pick paths\char`\"{}. A pick path is a hierarchical, ordered list of props that form an assembly. Most often, when a vtk\-Prop is picked, its path consists of a single node (i.\-e., the prop). However, classes like vtk\-Assembly and vtk\-Prop\-Assembly can return more than one path, each path being several layers deep. (See vtk\-Assembly\-Path for more information.) To use these methods -\/ first invoke Init\-Path\-Traversal() followed by repeated calls to Get\-Next\-Path(). Get\-Next\-Path() returns a N\-U\-L\-L pointer when the list is exhausted.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Paths ()} -\/ These methods are used by subclasses to place a matrix (if any) in the prop prior to rendering. Generally used only for picking. See vtk\-Prop3\-D for more information.  
\item {\ttfamily obj.\-Poke\-Matrix (vtk\-Matrix4x4 )} -\/ These methods are used by subclasses to place a matrix (if any) in the prop prior to rendering. Generally used only for picking. See vtk\-Prop3\-D for more information.  
\item {\ttfamily vtk\-Matrix4x4 = obj.\-Get\-Matrix ()} -\/ Set/\-Get property keys. Property keys can be digest by some rendering passes. For instance, the user may mark a prop as a shadow caster for a shadow mapping render pass. Keys are documented in render pass classes. Initial value is N\-U\-L\-L.  
\item {\ttfamily vtk\-Information = obj.\-Get\-Property\-Keys ()} -\/ Set/\-Get property keys. Property keys can be digest by some rendering passes. For instance, the user may mark a prop as a shadow caster for a shadow mapping render pass. Keys are documented in render pass classes. Initial value is N\-U\-L\-L.  
\item {\ttfamily obj.\-Set\-Property\-Keys (vtk\-Information keys)} -\/ Set/\-Get property keys. Property keys can be digest by some rendering passes. For instance, the user may mark a prop as a shadow caster for a shadow mapping render pass. Keys are documented in render pass classes. Initial value is N\-U\-L\-L.  
\item {\ttfamily bool = obj.\-Has\-Keys (vtk\-Information required\-Keys)} -\/ Tells if the prop has all the required keys. \begin{DoxyPrecond}{Precondition}
keys\-\_\-can\-\_\-be\-\_\-null\-: required\-Keys==0 $|$$|$ required\-Keys!=0  
\end{DoxyPrecond}

\end{DoxyItemize}\hypertarget{vtkcommon_vtkpropcollection}{}\section{vtk\-Prop\-Collection}\label{vtkcommon_vtkpropcollection}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Prop\-Collection represents and provides methods to manipulate a list of Props (i.\-e., vtk\-Prop and subclasses). The list is unsorted and duplicate entries are not prevented.

To create an instance of class vtk\-Prop\-Collection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPropCollection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Prop\-Collection has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Prop\-Collection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Prop\-Collection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Prop\-Collection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Item (vtk\-Prop a)} -\/ Add an Prop to the list.  
\item {\ttfamily vtk\-Prop = obj.\-Get\-Next\-Prop ()} -\/ Get the next Prop in the list.  
\item {\ttfamily vtk\-Prop = obj.\-Get\-Last\-Prop ()} -\/ Get the last Prop in the list.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Paths ()} -\/ Get the number of paths contained in this list. (Recall that a vtk\-Prop can consist of multiple parts.) Used in picking and other activities to get the parts of composite entities like vtk\-Assembly or vtk\-Prop\-Assembly.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkproperty2d}{}\section{vtk\-Property2\-D}\label{vtkcommon_vtkproperty2d}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Property2\-D contains properties used to render two dimensional images and annotations.

To create an instance of class vtk\-Property2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkProperty2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Property2\-D has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Property2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Property2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Property2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Property2\-D p)} -\/ Assign one property to another.  
\item {\ttfamily obj.\-Set\-Color (double , double , double )} -\/ Set/\-Get the R\-G\-B color of this property.  
\item {\ttfamily obj.\-Set\-Color (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the R\-G\-B color of this property.  
\item {\ttfamily double = obj. Get\-Color ()} -\/ Set/\-Get the R\-G\-B color of this property.  
\item {\ttfamily double = obj.\-Get\-Opacity ()} -\/ Set/\-Get the Opacity of this property.  
\item {\ttfamily obj.\-Set\-Opacity (double )} -\/ Set/\-Get the Opacity of this property.  
\item {\ttfamily obj.\-Set\-Point\-Size (float )} -\/ Set/\-Get the diameter of a Point. The size is expressed in screen units. This is only implemented for Open\-G\-L. The default is 1.\-0.  
\item {\ttfamily float = obj.\-Get\-Point\-Size\-Min\-Value ()} -\/ Set/\-Get the diameter of a Point. The size is expressed in screen units. This is only implemented for Open\-G\-L. The default is 1.\-0.  
\item {\ttfamily float = obj.\-Get\-Point\-Size\-Max\-Value ()} -\/ Set/\-Get the diameter of a Point. The size is expressed in screen units. This is only implemented for Open\-G\-L. The default is 1.\-0.  
\item {\ttfamily float = obj.\-Get\-Point\-Size ()} -\/ Set/\-Get the diameter of a Point. The size is expressed in screen units. This is only implemented for Open\-G\-L. The default is 1.\-0.  
\item {\ttfamily obj.\-Set\-Line\-Width (float )} -\/ Set/\-Get the width of a Line. The width is expressed in screen units. This is only implemented for Open\-G\-L. The default is 1.\-0.  
\item {\ttfamily float = obj.\-Get\-Line\-Width\-Min\-Value ()} -\/ Set/\-Get the width of a Line. The width is expressed in screen units. This is only implemented for Open\-G\-L. The default is 1.\-0.  
\item {\ttfamily float = obj.\-Get\-Line\-Width\-Max\-Value ()} -\/ Set/\-Get the width of a Line. The width is expressed in screen units. This is only implemented for Open\-G\-L. The default is 1.\-0.  
\item {\ttfamily float = obj.\-Get\-Line\-Width ()} -\/ Set/\-Get the width of a Line. The width is expressed in screen units. This is only implemented for Open\-G\-L. The default is 1.\-0.  
\item {\ttfamily obj.\-Set\-Line\-Stipple\-Pattern (int )} -\/ Set/\-Get the stippling pattern of a Line, as a 16-\/bit binary pattern (1 = pixel on, 0 = pixel off). This is only implemented for Open\-G\-L. The default is 0x\-F\-F\-F\-F.  
\item {\ttfamily int = obj.\-Get\-Line\-Stipple\-Pattern ()} -\/ Set/\-Get the stippling pattern of a Line, as a 16-\/bit binary pattern (1 = pixel on, 0 = pixel off). This is only implemented for Open\-G\-L. The default is 0x\-F\-F\-F\-F.  
\item {\ttfamily obj.\-Set\-Line\-Stipple\-Repeat\-Factor (int )} -\/ Set/\-Get the stippling repeat factor of a Line, which specifies how many times each bit in the pattern is to be repeated. This is only implemented for Open\-G\-L. The default is 1.  
\item {\ttfamily int = obj.\-Get\-Line\-Stipple\-Repeat\-Factor\-Min\-Value ()} -\/ Set/\-Get the stippling repeat factor of a Line, which specifies how many times each bit in the pattern is to be repeated. This is only implemented for Open\-G\-L. The default is 1.  
\item {\ttfamily int = obj.\-Get\-Line\-Stipple\-Repeat\-Factor\-Max\-Value ()} -\/ Set/\-Get the stippling repeat factor of a Line, which specifies how many times each bit in the pattern is to be repeated. This is only implemented for Open\-G\-L. The default is 1.  
\item {\ttfamily int = obj.\-Get\-Line\-Stipple\-Repeat\-Factor ()} -\/ Set/\-Get the stippling repeat factor of a Line, which specifies how many times each bit in the pattern is to be repeated. This is only implemented for Open\-G\-L. The default is 1.  
\item {\ttfamily obj.\-Set\-Display\-Location (int )} -\/ The Display\-Location is either background or foreground. If it is background, then this 2\-D actor will be drawn behind all 3\-D props or foreground 2\-D actors. If it is background, then this 2\-D actor will be drawn in front of all 3\-D props and background 2\-D actors. Within 2\-D actors of the same Display\-Location type, order is determined by the order in which the 2\-D actors were added to the viewport.  
\item {\ttfamily int = obj.\-Get\-Display\-Location\-Min\-Value ()} -\/ The Display\-Location is either background or foreground. If it is background, then this 2\-D actor will be drawn behind all 3\-D props or foreground 2\-D actors. If it is background, then this 2\-D actor will be drawn in front of all 3\-D props and background 2\-D actors. Within 2\-D actors of the same Display\-Location type, order is determined by the order in which the 2\-D actors were added to the viewport.  
\item {\ttfamily int = obj.\-Get\-Display\-Location\-Max\-Value ()} -\/ The Display\-Location is either background or foreground. If it is background, then this 2\-D actor will be drawn behind all 3\-D props or foreground 2\-D actors. If it is background, then this 2\-D actor will be drawn in front of all 3\-D props and background 2\-D actors. Within 2\-D actors of the same Display\-Location type, order is determined by the order in which the 2\-D actors were added to the viewport.  
\item {\ttfamily int = obj.\-Get\-Display\-Location ()} -\/ The Display\-Location is either background or foreground. If it is background, then this 2\-D actor will be drawn behind all 3\-D props or foreground 2\-D actors. If it is background, then this 2\-D actor will be drawn in front of all 3\-D props and background 2\-D actors. Within 2\-D actors of the same Display\-Location type, order is determined by the order in which the 2\-D actors were added to the viewport.  
\item {\ttfamily obj.\-Set\-Display\-Location\-To\-Background ()} -\/ The Display\-Location is either background or foreground. If it is background, then this 2\-D actor will be drawn behind all 3\-D props or foreground 2\-D actors. If it is background, then this 2\-D actor will be drawn in front of all 3\-D props and background 2\-D actors. Within 2\-D actors of the same Display\-Location type, order is determined by the order in which the 2\-D actors were added to the viewport.  
\item {\ttfamily obj.\-Set\-Display\-Location\-To\-Foreground ()} -\/ The Display\-Location is either background or foreground. If it is background, then this 2\-D actor will be drawn behind all 3\-D props or foreground 2\-D actors. If it is background, then this 2\-D actor will be drawn in front of all 3\-D props and background 2\-D actors. Within 2\-D actors of the same Display\-Location type, order is determined by the order in which the 2\-D actors were added to the viewport.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkquadratureschemedefinition}{}\section{vtk\-Quadrature\-Scheme\-Definition}\label{vtkcommon_vtkquadratureschemedefinition}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
An Elemental data type that holds a definition of a numerical quadrature scheme. The definition contains the requisite information to interpolate to the so called quadrature points of the specific scheme. namely\-:


\begin{DoxyPre}
 1)
 A matrix of shape function weights(shape functions evaluated
 at parametric coordinates of the quadrature points).\end{DoxyPre}



\begin{DoxyPre} 2)
 The number of quadrature points and cell nodes. These parameters
 size the matrix, and allow for convinent evaluation by users
 of the definition.
 \end{DoxyPre}


To create an instance of class vtk\-Quadrature\-Scheme\-Definition, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkQuadratureSchemeDefinition
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Quadrature\-Scheme\-Definition has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Quadrature\-Scheme\-Definition class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Quadrature\-Scheme\-Definition = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Quadrature\-Scheme\-Definition = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Deep\-Copy (vtk\-Quadrature\-Scheme\-Definition other)} -\/ Deep copy.  
\item {\ttfamily int = obj.\-Save\-State (vtk\-X\-M\-L\-Data\-Element e)} -\/ Put the object into an X\-M\-L representation. The element passed in is assumed to be empty.  
\item {\ttfamily int = obj.\-Restore\-State (vtk\-X\-M\-L\-Data\-Element e)} -\/ Restore the object from an X\-M\-L representation.  
\item {\ttfamily obj.\-Clear ()} -\/ Release all allocated resources and set the object to an unitialized state.  
\item {\ttfamily obj.\-Initialize (int cell\-Type, int number\-Of\-Nodes, int number\-Of\-Quadrature\-Points, double shape\-Function\-Weights)} -\/ Initialize the object allocating resources as needed.  
\item {\ttfamily obj.\-Initialize (int cell\-Type, int number\-Of\-Nodes, int number\-Of\-Quadrature\-Points, double shape\-Function\-Weights, double quadrature\-Weights)} -\/ Initialize the object allocating resources as needed.  
\item {\ttfamily int = obj.\-Get\-Cell\-Type () const} -\/ Access to an alternative key.  
\item {\ttfamily int = obj.\-Get\-Quadrature\-Key () const} -\/ Get the number of nodes associated with the interpolation.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Nodes () const} -\/ Get the number of quadrature points associated with the scheme.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Quadrature\-Points () const} -\/ Get the array of shape function weights. Shape function weights are the shape functions evaluated at the quadrature points. There are \char`\"{}\-Number\-Of\-Nodes\char`\"{} weights for each quadrature point.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkquadric}{}\section{vtk\-Quadric}\label{vtkcommon_vtkquadric}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Quadric evaluates the quadric function F(x,y,z) = a0$\ast$x$^\wedge$2 + a1$\ast$y$^\wedge$2 + a2$\ast$z$^\wedge$2 + a3$\ast$x$\ast$y + a4$\ast$y$\ast$z + a5$\ast$x$\ast$z + a6$\ast$x + a7$\ast$y + a8$\ast$z + a9. vtk\-Quadric is a concrete implementation of vtk\-Implicit\-Function.

To create an instance of class vtk\-Quadric, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkQuadric
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Quadric has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Quadric class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Quadric = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Quadric = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily double = obj.\-Evaluate\-Function (double x\mbox{[}3\mbox{]})}  
\item {\ttfamily double = obj.\-Evaluate\-Function (double x, double y, double z)}  
\item {\ttfamily obj.\-Evaluate\-Gradient (double x\mbox{[}3\mbox{]}, double g\mbox{[}3\mbox{]})}  
\item {\ttfamily obj.\-Set\-Coefficients (double a\mbox{[}10\mbox{]})}  
\item {\ttfamily obj.\-Set\-Coefficients (double a0, double a1, double a2, double a3, double a4, double a5, double a6, double a7, double a8, double a9)}  
\item {\ttfamily double = obj. Get\-Coefficients ()}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkrandomsequence}{}\section{vtk\-Random\-Sequence}\label{vtkcommon_vtkrandomsequence}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Random\-Sequence defines the interface of any sequence of random numbers.

At this level of abstraction, there is no assumption about the distribution of the numbers or about the quality of the sequence of numbers to be statistically independent. There is no assumption about the range of values.

To the question about why a random \char`\"{}sequence\char`\"{} class instead of a random \char`\"{}generator\char`\"{} class or to a random \char`\"{}number\char`\"{} class?, see the O\-O\-S\-C book\-: \char`\"{}\-Object-\/\-Oriented Software Construction\char`\"{}, 2nd Edition, by Bertrand Meyer. chapter 23, \char`\"{}\-Principles of class design\char`\"{}, \char`\"{}\-Pseudo-\/random number generators\-:
 a design exercise\char`\"{}, page 754--755.

To create an instance of class vtk\-Random\-Sequence, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRandomSequence
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Random\-Sequence has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Random\-Sequence class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Random\-Sequence = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Random\-Sequence = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily double = obj.\-Get\-Value ()} -\/ Current value  
\item {\ttfamily obj.\-Next ()} -\/ Move to the next number in the random sequence.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkreferencecount}{}\section{vtk\-Reference\-Count}\label{vtkcommon_vtkreferencecount}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Reference\-Count functionality has now been moved into vtk\-Object

To create an instance of class vtk\-Reference\-Count, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkReferenceCount
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Reference\-Count has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Reference\-Count class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Reference\-Count = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Reference\-Count = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkrungekutta2}{}\section{vtk\-Runge\-Kutta2}\label{vtkcommon_vtkrungekutta2}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is a concrete sub-\/class of vtk\-Initial\-Value\-Problem\-Solver. It uses a 2nd order Runge-\/\-Kutta method to obtain the values of a set of functions at the next time step.

To create an instance of class vtk\-Runge\-Kutta2, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRungeKutta2
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Runge\-Kutta2 has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Runge\-Kutta2 class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Runge\-Kutta2 = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Runge\-Kutta2 = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkrungekutta4}{}\section{vtk\-Runge\-Kutta4}\label{vtkcommon_vtkrungekutta4}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is a concrete sub-\/class of vtk\-Initial\-Value\-Problem\-Solver. It uses a 4th order Runge-\/\-Kutta method to obtain the values of a set of functions at the next time step.

To create an instance of class vtk\-Runge\-Kutta4, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRungeKutta4
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Runge\-Kutta4 has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Runge\-Kutta4 class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Runge\-Kutta4 = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Runge\-Kutta4 = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkrungekutta45}{}\section{vtk\-Runge\-Kutta45}\label{vtkcommon_vtkrungekutta45}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is a concrete sub-\/class of vtk\-Initial\-Value\-Problem\-Solver. It uses a 5th order Runge-\/\-Kutta method with stepsize control to obtain the values of a set of functions at the next time step. The stepsize is adjusted by calculating an estimated error using an embedded 4th order Runge-\/\-Kutta formula\-: Press, W. H. et al., 1992, Numerical Recipes in Fortran, Second Edition, Cambridge University Press Cash, J.\-R. and Karp, A.\-H. 1990, A\-C\-M Transactions on Mathematical Software, vol 16, pp 201-\/222

To create an instance of class vtk\-Runge\-Kutta45, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRungeKutta45
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Runge\-Kutta45 has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Runge\-Kutta45 class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Runge\-Kutta45 = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Runge\-Kutta45 = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkscalarstocolors}{}\section{vtk\-Scalars\-To\-Colors}\label{vtkcommon_vtkscalarstocolors}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Scalars\-To\-Colors is a general purpose superclass for objects that convert scalars to colors. This include vtk\-Lookup\-Table classes and color transfer functions.

The scalars to color mapping can be augmented with an additional uniform alpha blend. This is used, for example, to blend a vtk\-Actor's opacity with the lookup table values.

To create an instance of class vtk\-Scalars\-To\-Colors, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkScalarsToColors
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Scalars\-To\-Colors has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Scalars\-To\-Colors class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Scalars\-To\-Colors = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Scalars\-To\-Colors = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Is\-Opaque ()} -\/ Return true if all of the values defining the mapping have an opacity equal to 1. Default implementation return true.  
\item {\ttfamily obj.\-Build ()} -\/ Perform any processing required (if any) before processing scalars.  
\item {\ttfamily double = obj.\-Get\-Range ()} -\/ Sets/\-Gets the range of scalars which will be mapped.  
\item {\ttfamily obj.\-Set\-Range (double min, double max)} -\/ Sets/\-Gets the range of scalars which will be mapped.  
\item {\ttfamily obj.\-Set\-Range (double rng\mbox{[}2\mbox{]})} -\/ Map one value through the lookup table and return a color defined as a R\-G\-B\-A unsigned char tuple (4 bytes).  
\item {\ttfamily obj.\-Get\-Color (double v, double rgb\mbox{[}3\mbox{]})} -\/ Map one value through the lookup table and return the color as an R\-G\-B array of doubles between 0 and 1.  
\item {\ttfamily double = obj.\-Get\-Color (double v)} -\/ Map one value through the lookup table and return the alpha value (the opacity) as a double between 0 and 1.  
\item {\ttfamily double = obj.\-Get\-Opacity (double )} -\/ Map one value through the lookup table and return the luminance 0.\-3$\ast$red + 0.\-59$\ast$green + 0.\-11$\ast$blue as a double between 0 and 1. Returns the luminance value for the specified scalar value.  
\item {\ttfamily double = obj.\-Get\-Luminance (double x)} -\/ Specify an additional opacity (alpha) value to blend with. Values != 1 modify the resulting color consistent with the requested form of the output. This is typically used by an actor in order to blend its opacity.  
\item {\ttfamily obj.\-Set\-Alpha (double alpha)} -\/ Specify an additional opacity (alpha) value to blend with. Values != 1 modify the resulting color consistent with the requested form of the output. This is typically used by an actor in order to blend its opacity.  
\item {\ttfamily double = obj.\-Get\-Alpha ()} -\/ Specify an additional opacity (alpha) value to blend with. Values != 1 modify the resulting color consistent with the requested form of the output. This is typically used by an actor in order to blend its opacity.  
\item {\ttfamily vtk\-Unsigned\-Char\-Array = obj.\-Map\-Scalars (vtk\-Data\-Array scalars, int color\-Mode, int component)} -\/ An internal method maps a data array into a 4-\/component, unsigned char R\-G\-B\-A array. The color mode determines the behavior of mapping. If V\-T\-K\-\_\-\-C\-O\-L\-O\-R\-\_\-\-M\-O\-D\-E\-\_\-\-D\-E\-F\-A\-U\-L\-T is set, then unsigned char data arrays are treated as colors (and converted to R\-G\-B\-A if necessary); otherwise, the data is mapped through this instance of Scalars\-To\-Colors. The offset is used for data arrays with more than one component; it indicates which component to use to do the blending. When the component argument is -\/1, then the this object uses its own selected technique to change a vector into a scalar to map.  
\item {\ttfamily obj.\-Set\-Vector\-Mode (int )} -\/ Change mode that maps vectors by magnitude vs. component.  
\item {\ttfamily int = obj.\-Get\-Vector\-Mode ()} -\/ Change mode that maps vectors by magnitude vs. component.  
\item {\ttfamily obj.\-Set\-Vector\-Mode\-To\-Magnitude ()} -\/ Change mode that maps vectors by magnitude vs. component.  
\item {\ttfamily obj.\-Set\-Vector\-Mode\-To\-Component ()} -\/ Change mode that maps vectors by magnitude vs. component.  
\item {\ttfamily obj.\-Set\-Vector\-Component (int )} -\/ If the mapper does not select which component of a vector to map to colors, you can specify it here.  
\item {\ttfamily int = obj.\-Get\-Vector\-Component ()} -\/ If the mapper does not select which component of a vector to map to colors, you can specify it here.  
\item {\ttfamily obj.\-Map\-Scalars\-Through\-Table (vtk\-Data\-Array scalars, string output, int output\-Format)} -\/ Map a set of scalars through the lookup table in a single operation. The output format can be set to V\-T\-K\-\_\-\-R\-G\-B\-A (4 components), V\-T\-K\-\_\-\-R\-G\-B (3 components), V\-T\-K\-\_\-\-L\-U\-M\-I\-N\-A\-N\-C\-E (1 component, greyscale), or V\-T\-K\-\_\-\-L\-U\-M\-I\-N\-A\-N\-C\-E\-\_\-\-A\-L\-P\-H\-A (2 components) If not supplied, the output format defaults to R\-G\-B\-A.  
\item {\ttfamily obj.\-Map\-Scalars\-Through\-Table (vtk\-Data\-Array scalars, string output)} -\/ An internal method typically not used in applications.  
\item {\ttfamily vtk\-Unsigned\-Char\-Array = obj.\-Convert\-Unsigned\-Char\-To\-R\-G\-B\-A (vtk\-Unsigned\-Char\-Array colors, int num\-Comp, int num\-Tuples)} -\/ An internal method used to convert a color array to R\-G\-B\-A. The method instantiates a vtk\-Unsigned\-Char\-Array and returns it. The user is responsible for managing the memory.  
\item {\ttfamily int = obj.\-Using\-Log\-Scale ()} -\/ This should return 1 is the subclass is using log scale for mapping scalars to colors. Default implementation returns 0.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkserversocket}{}\section{vtk\-Server\-Socket}\label{vtkcommon_vtkserversocket}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
To create an instance of class vtk\-Server\-Socket, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkServerSocket
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Server\-Socket has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Server\-Socket class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Server\-Socket = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Server\-Socket = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Create\-Server (int port)} -\/ Creates a server socket at a given port and binds to it. Returns -\/1 on error. 0 on success.  
\item {\ttfamily vtk\-Client\-Socket = obj.\-Wait\-For\-Connection (long msec)} -\/ Waits for a connection. When a connection is received a new vtk\-Client\-Socket object is created and returned. Returns N\-U\-L\-L on timeout.  
\item {\ttfamily int = obj.\-Get\-Server\-Port ()} -\/ Returns the port on which the server is running.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkshortarray}{}\section{vtk\-Short\-Array}\label{vtkcommon_vtkshortarray}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Short\-Array is an array of values of type short. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Short\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkShortArray
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Short\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Short\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Short\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Short\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()} -\/ Copy the tuple value into a user-\/provided array.  
\item {\ttfamily obj.\-Get\-Tuple\-Value (vtk\-Id\-Type i, short tuple)} -\/ Set the tuple value at the ith location in the array.  
\item {\ttfamily obj.\-Set\-Tuple\-Value (vtk\-Id\-Type i, short tuple)} -\/ Insert (memory allocation performed) the tuple into the ith location in the array.  
\item {\ttfamily obj.\-Insert\-Tuple\-Value (vtk\-Id\-Type i, short tuple)} -\/ Insert (memory allocation performed) the tuple onto the end of the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Tuple\-Value (short tuple)} -\/ Get the data at a particular index.  
\item {\ttfamily short = obj.\-Get\-Value (vtk\-Id\-Type id)} -\/ Set the data at a particular index. Does not do range checking. Make sure you use the method Set\-Number\-Of\-Values() before inserting data.  
\item {\ttfamily obj.\-Set\-Value (vtk\-Id\-Type id, short value)} -\/ Specify the number of values for this object to hold. Does an allocation as well as setting the Max\-Id ivar. Used in conjunction with Set\-Value() method for fast insertion.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Values (vtk\-Id\-Type number)} -\/ Insert data at a specified position in the array.  
\item {\ttfamily obj.\-Insert\-Value (vtk\-Id\-Type id, short f)} -\/ Insert data at the end of the array. Return its location in the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Value (short f)} -\/ Get the address of a particular data index. Make sure data is allocated for the number of items requested. Set Max\-Id according to the number of data values requested.  
\item {\ttfamily obj.\-Set\-Array (short array, vtk\-Id\-Type size, int save)} -\/ This method lets the user specify data to be held by the array. The array argument is a pointer to the data. size is the size of the array supplied by the user. Set save to 1 to keep the class from deleting the array when it cleans up or reallocates memory. The class uses the actual array provided; it does not copy the data from the suppled array.  
\item {\ttfamily obj.\-Set\-Array (short array, vtk\-Id\-Type size, int save, int delete\-Method)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtksignedchararray}{}\section{vtk\-Signed\-Char\-Array}\label{vtkcommon_vtksignedchararray}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Signed\-Char\-Array is an array of values of type signed char. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Signed\-Char\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSignedCharArray
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Signed\-Char\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Signed\-Char\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Signed\-Char\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Signed\-Char\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()} -\/ Copy the tuple value into a user-\/provided array.  
\item {\ttfamily signed = obj.\-char Get\-Value (vtk\-Id\-Type id)} -\/ Set the data at a particular index. Does not do range checking. Make sure you use the method Set\-Number\-Of\-Values() before inserting data.  
\item {\ttfamily obj.\-Set\-Value (vtk\-Id\-Type id, signed char value)} -\/ Specify the number of values for this object to hold. Does an allocation as well as setting the Max\-Id ivar. Used in conjunction with Set\-Value() method for fast insertion.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Values (vtk\-Id\-Type number)} -\/ Insert data at a specified position in the array.  
\item {\ttfamily obj.\-Insert\-Value (vtk\-Id\-Type id, signed char f)} -\/ Insert data at the end of the array. Return its location in the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Value (signed char f)} -\/ Get the address of a particular data index. Make sure data is allocated for the number of items requested. Set Max\-Id according to the number of data values requested.  
\item {\ttfamily signed = obj.\-string Write\-Pointer (vtk\-Id\-Type id, vtk\-Id\-Type number)} -\/ Get the address of a particular data index. Performs no checks to verify that the memory has been allocated etc.  
\item {\ttfamily signed = obj.\-string Get\-Pointer (vtk\-Id\-Type id)} -\/ This method lets the user specify data to be held by the array. The array argument is a pointer to the data. size is the size of the array supplied by the user. Set save to 1 to keep the class from deleting the array when it cleans up or reallocates memory. The class uses the actual array provided; it does not copy the data from the suppled array.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtksocket}{}\section{vtk\-Socket}\label{vtkcommon_vtksocket}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This abstract class encapsulates a B\-S\-D socket. It provides an A\-P\-I for basic socket operations.

To create an instance of class vtk\-Socket, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSocket
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Socket has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Socket class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Socket = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Socket = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Connected ()} -\/ Close the socket.  
\item {\ttfamily obj.\-Close\-Socket ()} -\/ These methods send data over the socket. Returns 1 on success, 0 on error and raises vtk\-Command\-::\-Error\-Event.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtksocketcollection}{}\section{vtk\-Socket\-Collection}\label{vtkcommon_vtksocketcollection}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Apart from being vtk\-Collection subclass for sockets, this class provides means to wait for activity on all the sockets in the collection simultaneously.

To create an instance of class vtk\-Socket\-Collection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSocketCollection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Socket\-Collection has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Socket\-Collection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Socket\-Collection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Socket\-Collection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Item (vtk\-Socket soc)}  
\item {\ttfamily int = obj.\-Select\-Sockets (long msec)} -\/ Select all Connected sockets in the collection. If msec is specified, it timesout after msec milliseconds on inactivity. Returns 0 on timeout, -\/1 on error; 1 is a socket was selected. The selected socket can be retrieved by Get\-Last\-Selected\-Socket().  
\item {\ttfamily vtk\-Socket = obj.\-Get\-Last\-Selected\-Socket ()} -\/ Overridden to unset Selected\-Socket.  
\item {\ttfamily obj.\-Replace\-Item (int i, vtk\-Object )} -\/ Overridden to unset Selected\-Socket.  
\item {\ttfamily obj.\-Remove\-Item (int i)} -\/ Overridden to unset Selected\-Socket.  
\item {\ttfamily obj.\-Remove\-Item (vtk\-Object )} -\/ Overridden to unset Selected\-Socket.  
\item {\ttfamily obj.\-Remove\-All\-Items ()} -\/ Overridden to unset Selected\-Socket.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtksphericaltransform}{}\section{vtk\-Spherical\-Transform}\label{vtkcommon_vtksphericaltransform}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Spherical\-Transform will convert (r,phi,theta) coordinates to (x,y,z) coordinates and back again. The angles are given in radians. By default, it converts spherical coordinates to rectangular, but Get\-Inverse() returns a transform that will do the opposite. The equation that is used is x = r$\ast$sin(phi)$\ast$cos(theta), y = r$\ast$sin(phi)$\ast$sin(theta), z = r$\ast$cos(phi).

To create an instance of class vtk\-Spherical\-Transform, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSphericalTransform
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Spherical\-Transform has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Spherical\-Transform class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Spherical\-Transform = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Spherical\-Transform = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Make\-Transform ()} -\/ Make another transform of the same type.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkstringarray}{}\section{vtk\-String\-Array}\label{vtkcommon_vtkstringarray}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Points and cells may sometimes have associated data that are stored as strings, e.\-g. many information visualization projects. This class provides a reasonably clean way to store and access those.

To create an instance of class vtk\-String\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkStringArray
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-String\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-String\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-String\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-String\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()}  
\item {\ttfamily int = obj.\-Is\-Numeric ()} -\/ Release storage and reset array to initial state.  
\item {\ttfamily obj.\-Initialize ()} -\/ Release storage and reset array to initial state.  
\item {\ttfamily int = obj.\-Get\-Data\-Type\-Size ()} -\/ Return the size of the data type. W\-A\-R\-N\-I\-N\-G\-: This may not mean what you expect with strings. It will return sizeof(vtkstd\-::string) and not take into account the data included in any particular string.  
\item {\ttfamily obj.\-Squeeze ()} -\/ Resize the array while conserving the data.  
\item {\ttfamily int = obj.\-Resize (vtk\-Id\-Type num\-Tuples)} -\/ Resize the array while conserving the data.  
\item {\ttfamily obj.\-Set\-Tuple (vtk\-Id\-Type i, vtk\-Id\-Type j, vtk\-Abstract\-Array source)} -\/ Set the tuple at the ith location using the jth tuple in the source array. This method assumes that the two arrays have the same type and structure. Note that range checking and memory allocation is not performed; use in conjunction with Set\-Number\-Of\-Tuples() to allocate space.  
\item {\ttfamily obj.\-Insert\-Tuple (vtk\-Id\-Type i, vtk\-Id\-Type j, vtk\-Abstract\-Array source)} -\/ Insert the jth tuple in the source array, at ith location in this array. Note that memory allocation is performed as necessary to hold the data.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Tuple (vtk\-Id\-Type j, vtk\-Abstract\-Array source)} -\/ Insert the jth tuple in the source array, at the end in this array. Note that memory allocation is performed as necessary to hold the data. Returns the location at which the data was inserted.  
\item {\ttfamily obj.\-Interpolate\-Tuple (vtk\-Id\-Type i, vtk\-Id\-List pt\-Indices, vtk\-Abstract\-Array source, double weights)} -\/ Set the ith tuple in this array as the interpolated tuple value, given the pt\-Indices in the source array and associated interpolation weights. This method assumes that the two arrays are of the same type and strcuture.  
\item {\ttfamily obj.\-Interpolate\-Tuple (vtk\-Id\-Type i, vtk\-Id\-Type id1, vtk\-Abstract\-Array source1, vtk\-Id\-Type id2, vtk\-Abstract\-Array source2, double t)}  
\item {\ttfamily obj.\-Get\-Tuples (vtk\-Id\-List pt\-Ids, vtk\-Abstract\-Array output)} -\/ Given a list of indices, return an array of values. You must insure that the output array has been previously allocated with enough space to hold the data and that the types match sufficiently to allow conversion (if necessary).  
\item {\ttfamily obj.\-Get\-Tuples (vtk\-Id\-Type p1, vtk\-Id\-Type p2, vtk\-Abstract\-Array output)} -\/ Get the values for the range of indices specified (i.\-e., p1-\/$>$p2 inclusive). You must insure that the output array has been previously allocated with enough space to hold the data and that the type of the output array is compatible with the type of this array.  
\item {\ttfamily int = obj.\-Allocate (vtk\-Id\-Type sz, vtk\-Id\-Type ext)} -\/ Allocate memory for this array. Delete old storage only if necessary. Note that ext is no longer used.  
\item {\ttfamily vtk\-Std\-String = obj.\&Get\-Value (vtk\-Id\-Type id)} -\/ Get the data at a particular index.  
\item {\ttfamily obj.\-Set\-Value (vtk\-Id\-Type id, string value)} -\/ Set the data at a particular index. Does not do range checking. Make sure you use the method Set\-Number\-Of\-Values() before inserting data.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Tuples (vtk\-Id\-Type number)} -\/ Specify the number of values for this object to hold. Does an allocation as well as setting the Max\-Id ivar. Used in conjunction with Set\-Value() method for fast insertion.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Values (vtk\-Id\-Type number)} -\/ Specify the number of values for this object to hold. Does an allocation as well as setting the Max\-Id ivar. Used in conjunction with Set\-Value() method for fast insertion.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Values ()}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Element\-Components ()}  
\item {\ttfamily int = obj.\-Get\-Element\-Component\-Size ()} -\/ Insert data at a specified position in the array.  
\item {\ttfamily obj.\-Insert\-Value (vtk\-Id\-Type id, string val)} -\/ Insert data at a specified position in the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Value (string f)} -\/ Insert data at the end of the array. Return its location in the array.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Abstract\-Array aa)} -\/ Deep copy of another string array. Will complain and change nothing if the array passed in is not a vtk\-String\-Array.  
\item {\ttfamily long = obj.\-Get\-Actual\-Memory\-Size ()} -\/ Return the memory in kilobytes consumed by this data array. Used to support streaming and reading/writing data. The value returned is guaranteed to be greater than or equal to the memory required to actually represent the data represented by this object. The information returned is valid only after the pipeline has been updated.

This function takes into account the size of the contents of the strings as well as the string containers themselves.  
\item {\ttfamily vtk\-Array\-Iterator = obj.\-New\-Iterator ()} -\/ Returns a vtk\-Array\-Iterator\-Template$<$vtk\-Std\-String$>$.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Data\-Size ()} -\/ Returns the size of the data in Data\-Type\-Size units. Thus, the number of bytes for the data can be computed by Get\-Data\-Size() $\ast$ Get\-Data\-Type\-Size(). The size computation includes the string termination character for each string.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Lookup\-Value (string value)}  
\item {\ttfamily obj.\-Lookup\-Value (string value, vtk\-Id\-List ids)}  
\item {\ttfamily obj.\-Data\-Changed ()} -\/ Tell the array explicitly that the data has changed. This is only necessary to call when you modify the array contents without using the array's A\-P\-I (i.\-e. you retrieve a pointer to the data and modify the array contents). You need to call this so that the fast lookup will know to rebuild itself. Otherwise, the lookup functions will give incorrect results.  
\item {\ttfamily obj.\-Data\-Element\-Changed (vtk\-Id\-Type id)} -\/ Tell the array explicitly that a single data element has changed. Like Data\-Changed(), then is only necessary when you modify the array contents without using the array's A\-P\-I.  
\item {\ttfamily obj.\-Clear\-Lookup ()} -\/ Delete the associated fast lookup data structure on this array, if it exists. The lookup will be rebuilt on the next call to a lookup function.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkstructureddata}{}\section{vtk\-Structured\-Data}\label{vtkcommon_vtkstructureddata}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Structured\-Data is an abstract class that specifies an interface for topologically regular data. Regular data is data that can be accessed in rectangular fashion using an i-\/j-\/k index. A finite difference grid, a volume, or a pixmap are all considered regular.

To create an instance of class vtk\-Structured\-Data, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkStructuredData
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Structured\-Data has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Structured\-Data class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Structured\-Data = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Structured\-Data = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkstructuredvisibilityconstraint}{}\section{vtk\-Structured\-Visibility\-Constraint}\label{vtkcommon_vtkstructuredvisibilityconstraint}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Structured\-Visibility\-Constraint is a general class to manage a list of points/cell marked as invalid or invisible. Currently, it does this by maintaining an unsigned char array associated with points/cells. To conserve memory, this array is allocated only when it is needed (when Blank() is called the first time). Make sure to call Initialize() with the right dimensions before calling any methods that set/get visibility.

To create an instance of class vtk\-Structured\-Visibility\-Constraint, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkStructuredVisibilityConstraint
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Structured\-Visibility\-Constraint has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Structured\-Visibility\-Constraint class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Structured\-Visibility\-Constraint = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Structured\-Visibility\-Constraint = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily char = obj.\-Is\-Visible (vtk\-Id\-Type id)} -\/ Returns 1 is the point/cell is visible, 0 otherwise.  
\item {\ttfamily obj.\-Blank (vtk\-Id\-Type id)} -\/ Sets the visibility flag of the given point/cell off. The first time blank is called, a new visibility array is created if it doesn't exist.  
\item {\ttfamily obj.\-Un\-Blank (vtk\-Id\-Type id)} -\/ Sets the visibility flag of the given point/cell on.  
\item {\ttfamily int = obj. Get\-Dimensions ()} -\/ Get the dimensions used to initialize the object.  
\item {\ttfamily obj.\-Initialize (int dims\mbox{[}3\mbox{]})} -\/ Set the dimensions and set the Initialized flag to 1. Once an object is initialized, it's dimensions can not be changed anymore.  
\item {\ttfamily obj.\-Set\-Visibility\-By\-Id (vtk\-Unsigned\-Char\-Array vis)} -\/ Set/\-Get the array used to store the visibility flags.  
\item {\ttfamily vtk\-Unsigned\-Char\-Array = obj.\-Get\-Visibility\-By\-Id ()} -\/ Set/\-Get the array used to store the visibility flags.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Structured\-Visibility\-Constraint src)} -\/ Copies the dimensions, the visibility array pointer and the initialized flag.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Structured\-Visibility\-Constraint src)} -\/ Copies the dimensions, the visibility array and the initialized flag.  
\item {\ttfamily char = obj.\-Is\-Constrained ()}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtktableextenttranslator}{}\section{vtk\-Table\-Extent\-Translator}\label{vtkcommon_vtktableextenttranslator}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Table\-Extent\-Translator provides a vtk\-Extent\-Translator that is programmed with a specific extent corresponding to each piece number. Readers can provide this to an application to allow the pipeline to execute using the same piece breakdown that is provided in the input file.

To create an instance of class vtk\-Table\-Extent\-Translator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTableExtentTranslator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Table\-Extent\-Translator has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Table\-Extent\-Translator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Table\-Extent\-Translator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Table\-Extent\-Translator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Number\-Of\-Pieces (int pieces)}  
\item {\ttfamily obj.\-Set\-Number\-Of\-Pieces\-In\-Table (int pieces)} -\/ Set the real number of pieces in the extent table.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Pieces\-In\-Table ()} -\/ Set the real number of pieces in the extent table.  
\item {\ttfamily int = obj.\-Piece\-To\-Extent ()} -\/ Called to translate the current piece into an extent. This is not thread safe.  
\item {\ttfamily int = obj.\-Piece\-To\-Extent\-By\-Points ()} -\/ Not supported by this subclass of vtk\-Extent\-Translator.  
\item {\ttfamily int = obj.\-Piece\-To\-Extent\-Thread\-Safe (int piece, int num\-Pieces, int ghost\-Level, int whole\-Extent, int result\-Extent, int split\-Mode, int by\-Points)} -\/ Not supported by this subclass of vtk\-Extent\-Translator.  
\item {\ttfamily obj.\-Set\-Extent\-For\-Piece (int piece, int extent)} -\/ Set the extent to be used for a piece. This sets the extent table entry for the piece.  
\item {\ttfamily obj.\-Get\-Extent\-For\-Piece (int piece, int extent)} -\/ Get the extent table entry for the given piece. This is only for code that is setting up the table. Extent translation should always be done through the Piece\-To\-Extent method.  
\item {\ttfamily obj.\-Set\-Maximum\-Ghost\-Level (int )} -\/ Set the maximum ghost level that can be requested. This can be used by a reader to make sure an extent request does not go outside the boundaries of the piece's file.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Ghost\-Level ()} -\/ Set the maximum ghost level that can be requested. This can be used by a reader to make sure an extent request does not go outside the boundaries of the piece's file.  
\item {\ttfamily obj.\-Set\-Piece\-Available (int piece, int available)} -\/ Get/\-Set whether the given piece is available. Requesting a piece that is not available will produce errors in the pipeline.  
\item {\ttfamily int = obj.\-Get\-Piece\-Available (int piece)} -\/ Get/\-Set whether the given piece is available. Requesting a piece that is not available will produce errors in the pipeline.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtktensor}{}\section{vtk\-Tensor}\label{vtkcommon_vtktensor}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Tensor is a floating point representation of an nxn tensor. vtk\-Tensor provides methods for assignment and reference of tensor components. It does it in such a way as to minimize data copying.

To create an instance of class vtk\-Tensor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTensor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Tensor has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Tensor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Tensor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Tensor = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Initialize ()} -\/ Initialize tensor components to 0.\-0.  
\item {\ttfamily double = obj.\-Get\-Component (int i, int j)} -\/ Get the tensor component (i,j).  
\item {\ttfamily obj.\-Set\-Component (int i, int j, double v)} -\/ Set the value of the tensor component (i,j).  
\item {\ttfamily obj.\-Add\-Component (int i, int j, double v)} -\/ Add to the value of the tensor component at location (i,j).  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Tensor t)} -\/ Deep copy of one tensor to another tensor.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkthreadmessager}{}\section{vtk\-Thread\-Messager}\label{vtkcommon_vtkthreadmessager}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Multithreader is a class that provides support for messaging between threads multithreaded using pthreads or Windows messaging.

To create an instance of class vtk\-Thread\-Messager, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkThreadMessager
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Thread\-Messager has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Thread\-Messager class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Thread\-Messager = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Thread\-Messager = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Wait\-For\-Message ()} -\/ Wait (block, non-\/busy) until another thread sends a message.  
\item {\ttfamily obj.\-Send\-Wake\-Message ()} -\/ Send a message to all threads who are waiting via Wait\-For\-Message().  
\item {\ttfamily obj.\-Enable\-Wait\-For\-Receiver ()} -\/ pthreads only. If the wait is enabled, the thread who is to call Wait\-For\-Message() will block until a receiver thread is ready to receive.  
\item {\ttfamily obj.\-Disable\-Wait\-For\-Receiver ()} -\/ pthreads only. If the wait is enabled, the thread who is to call Wait\-For\-Message() will block until a receiver thread is ready to receive.  
\item {\ttfamily obj.\-Wait\-For\-Receiver ()} -\/ pthreads only. If wait is enable, this will block until one thread is ready to receive a message.  
\item {\ttfamily obj.\-Send\-Message ()} -\/  
\end{DoxyItemize}\hypertarget{vtkcommon_vtktimepointutility}{}\section{vtk\-Time\-Point\-Utility}\label{vtkcommon_vtktimepointutility}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Time\-Point\-Utility is provides methods to perform common time operations.

To create an instance of class vtk\-Time\-Point\-Utility, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTimePointUtility
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Time\-Point\-Utility has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Time\-Point\-Utility class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Time\-Point\-Utility = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Time\-Point\-Utility = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtktimerlog}{}\section{vtk\-Timer\-Log}\label{vtkcommon_vtktimerlog}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Timer\-Log contains walltime and cputime measurements associated with a given event. These results can be later analyzed when \char`\"{}dumping out\char`\"{} the table.

In addition, vtk\-Timer\-Log allows the user to simply get the current time, and to start/stop a simple timer separate from the timing table logging.

To create an instance of class vtk\-Timer\-Log, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTimerLog
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Timer\-Log has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Timer\-Log class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Timer\-Log = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Timer\-Log = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Start\-Timer ()} -\/ Set the Start\-Time to the current time. Used with Get\-Elapsed\-Time().  
\item {\ttfamily obj.\-Stop\-Timer ()} -\/ Sets End\-Time to the current time. Used with Get\-Elapsed\-Time().  
\item {\ttfamily double = obj.\-Get\-Elapsed\-Time ()} -\/ Returns the difference between Start\-Time and End\-Time as a doubleing point value indicating the elapsed time in seconds.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtktransform}{}\section{vtk\-Transform}\label{vtkcommon_vtktransform}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
A vtk\-Transform can be used to describe the full range of linear (also known as affine) coordinate transformations in three dimensions, which are internally represented as a 4x4 homogeneous transformation matrix. When you create a new vtk\-Transform, it is always initialized to the identity transformation. 

The Set\-Input() method allows you to set another transform, instead of the identity transform, to be the base transformation. There is a pipeline mechanism to ensure that when the input is modified, the current transformation will be updated accordingly. This pipeline mechanism is also supported by the Concatenate() method. 

Most of the methods for manipulating this transformation, e.\-g. Translate, Rotate, and Concatenate, can operate in either Pre\-Multiply (the default) or Post\-Multiply mode. In Pre\-Multiply mode, the translation, concatenation, etc. will occur before any transformations which are represented by the current matrix. In Post\-Multiply mode, the additional transformation will occur after any transformations represented by the current matrix. 

This class performs all of its operations in a right handed coordinate system with right handed rotations. Some other graphics libraries use left handed coordinate systems and rotations.

To create an instance of class vtk\-Transform, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTransform
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Transform has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Transform class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Transform = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Transform = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Identity ()} -\/ Set the transformation to the identity transformation. If the transform has an Input, then the transformation will be reset so that it is the same as the Input.  
\item {\ttfamily obj.\-Inverse ()} -\/ Invert the transformation. This will also set a flag so that the transformation will use the inverse of its Input, if an Input has been set.  
\item {\ttfamily obj.\-Translate (double x, double y, double z)} -\/ Create a translation matrix and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Translate (double x\mbox{[}3\mbox{]})} -\/ Create a translation matrix and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Translate (float x\mbox{[}3\mbox{]})} -\/ Create a translation matrix and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Rotate\-W\-X\-Y\-Z (double angle, double x, double y, double z)} -\/ Create a rotation matrix and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics. The angle is in degrees, and (x,y,z) specifies the axis that the rotation will be performed around.  
\item {\ttfamily obj.\-Rotate\-W\-X\-Y\-Z (double angle, double axis\mbox{[}3\mbox{]})} -\/ Create a rotation matrix and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics. The angle is in degrees, and (x,y,z) specifies the axis that the rotation will be performed around.  
\item {\ttfamily obj.\-Rotate\-W\-X\-Y\-Z (double angle, float axis\mbox{[}3\mbox{]})} -\/ Create a rotation matrix and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics. The angle is in degrees, and (x,y,z) specifies the axis that the rotation will be performed around.  
\item {\ttfamily obj.\-Rotate\-X (double angle)} -\/ Create a rotation matrix about the X, Y, or Z axis and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics. The angle is expressed in degrees.  
\item {\ttfamily obj.\-Rotate\-Y (double angle)} -\/ Create a rotation matrix about the X, Y, or Z axis and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics. The angle is expressed in degrees.  
\item {\ttfamily obj.\-Rotate\-Z (double angle)} -\/ Create a rotation matrix about the X, Y, or Z axis and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics. The angle is expressed in degrees.  
\item {\ttfamily obj.\-Scale (double x, double y, double z)} -\/ Create a scale matrix (i.\-e. set the diagonal elements to x, y, z) and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Scale (double s\mbox{[}3\mbox{]})} -\/ Create a scale matrix (i.\-e. set the diagonal elements to x, y, z) and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Scale (float s\mbox{[}3\mbox{]})} -\/ Create a scale matrix (i.\-e. set the diagonal elements to x, y, z) and concatenate it with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Set\-Matrix (vtk\-Matrix4x4 matrix)} -\/ Set the current matrix directly. This actually calls Identity(), followed by Concatenate(matrix).  
\item {\ttfamily obj.\-Set\-Matrix (double elements\mbox{[}16\mbox{]})} -\/ Set the current matrix directly. This actually calls Identity(), followed by Concatenate(matrix).  
\item {\ttfamily obj.\-Concatenate (vtk\-Matrix4x4 matrix)} -\/ Concatenates the matrix with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Concatenate (double elements\mbox{[}16\mbox{]})} -\/ Concatenates the matrix with the current transformation according to Pre\-Multiply or Post\-Multiply semantics.  
\item {\ttfamily obj.\-Concatenate (vtk\-Linear\-Transform transform)} -\/ Concatenate the specified transform with the current transformation according to Pre\-Multiply or Post\-Multiply semantics. The concatenation is pipelined, meaning that if any of the transformations are changed, even after Concatenate() is called, those changes will be reflected when you call Transform\-Point().  
\item {\ttfamily obj.\-Pre\-Multiply ()} -\/ Sets the internal state of the transform to Pre\-Multiply. All subsequent operations will occur before those already represented in the current transformation. In homogeneous matrix notation, M = M$\ast$\-A where M is the current transformation matrix and A is the applied matrix. The default is Pre\-Multiply.  
\item {\ttfamily obj.\-Post\-Multiply ()} -\/ Sets the internal state of the transform to Post\-Multiply. All subsequent operations will occur after those already represented in the current transformation. In homogeneous matrix notation, M = A$\ast$\-M where M is the current transformation matrix and A is the applied matrix. The default is Pre\-Multiply.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Concatenated\-Transforms ()} -\/ Get the total number of transformations that are linked into this one via Concatenate() operations or via Set\-Input().  
\item {\ttfamily vtk\-Linear\-Transform = obj.\-Get\-Concatenated\-Transform (int i)} -\/ Get the x, y, z orientation angles from the transformation matrix as an array of three floating point values.  
\item {\ttfamily obj.\-Get\-Orientation (double orient\mbox{[}3\mbox{]})} -\/ Get the x, y, z orientation angles from the transformation matrix as an array of three floating point values.  
\item {\ttfamily obj.\-Get\-Orientation (float orient\mbox{[}3\mbox{]})} -\/ Get the x, y, z orientation angles from the transformation matrix as an array of three floating point values.  
\item {\ttfamily double = obj.\-Get\-Orientation ()} -\/ Get the x, y, z orientation angles from the transformation matrix as an array of three floating point values.  
\item {\ttfamily obj.\-Get\-Orientation\-W\-X\-Y\-Z (double wxyz\mbox{[}4\mbox{]})} -\/ Return the wxyz angle+axis representing the current orientation. The angle is in degrees and the axis is a unit vector.  
\item {\ttfamily obj.\-Get\-Orientation\-W\-X\-Y\-Z (float wxyz\mbox{[}4\mbox{]})} -\/ Return the wxyz angle+axis representing the current orientation. The angle is in degrees and the axis is a unit vector.  
\item {\ttfamily double = obj.\-Get\-Orientation\-W\-X\-Y\-Z ()} -\/ Return the wxyz angle+axis representing the current orientation. The angle is in degrees and the axis is a unit vector.  
\item {\ttfamily obj.\-Get\-Position (double pos\mbox{[}3\mbox{]})} -\/ Return the position from the current transformation matrix as an array of three floating point numbers. This is simply returning the translation component of the 4x4 matrix.  
\item {\ttfamily obj.\-Get\-Position (float pos\mbox{[}3\mbox{]})} -\/ Return the position from the current transformation matrix as an array of three floating point numbers. This is simply returning the translation component of the 4x4 matrix.  
\item {\ttfamily double = obj.\-Get\-Position ()} -\/ Return the position from the current transformation matrix as an array of three floating point numbers. This is simply returning the translation component of the 4x4 matrix.  
\item {\ttfamily obj.\-Get\-Scale (double scale\mbox{[}3\mbox{]})} -\/ Return the scale factors of the current transformation matrix as an array of three float numbers. These scale factors are not necessarily about the x, y, and z axes unless unless the scale transformation was applied before any rotations.  
\item {\ttfamily obj.\-Get\-Scale (float scale\mbox{[}3\mbox{]})} -\/ Return the scale factors of the current transformation matrix as an array of three float numbers. These scale factors are not necessarily about the x, y, and z axes unless unless the scale transformation was applied before any rotations.  
\item {\ttfamily double = obj.\-Get\-Scale ()} -\/ Return the scale factors of the current transformation matrix as an array of three float numbers. These scale factors are not necessarily about the x, y, and z axes unless unless the scale transformation was applied before any rotations.  
\item {\ttfamily obj.\-Get\-Inverse (vtk\-Matrix4x4 inverse)} -\/ Return a matrix which is the inverse of the current transformation matrix.  
\item {\ttfamily obj.\-Get\-Transpose (vtk\-Matrix4x4 transpose)} -\/ Return a matrix which is the transpose of the current transformation matrix. This is equivalent to the inverse if and only if the transformation is a pure rotation with no translation or scale.  
\item {\ttfamily obj.\-Set\-Input (vtk\-Linear\-Transform input)} -\/ Set the input for this transformation. This will be used as the base transformation if it is set. This method allows you to build a transform pipeline\-: if the input is modified, then this transformation will automatically update accordingly. Note that the Inverse\-Flag, controlled via Inverse(), determines whether this transformation will use the Input or the inverse of the Input.  
\item {\ttfamily vtk\-Linear\-Transform = obj.\-Get\-Input ()} -\/ Set the input for this transformation. This will be used as the base transformation if it is set. This method allows you to build a transform pipeline\-: if the input is modified, then this transformation will automatically update accordingly. Note that the Inverse\-Flag, controlled via Inverse(), determines whether this transformation will use the Input or the inverse of the Input.  
\item {\ttfamily int = obj.\-Get\-Inverse\-Flag ()} -\/ Get the inverse flag of the transformation. This controls whether it is the Input or the inverse of the Input that is used as the base transformation. The Inverse\-Flag is flipped every time Inverse() is called. The Inverse\-Flag is off when a transform is first created.  
\item {\ttfamily obj.\-Push ()} -\/ Pushes the current transformation onto the transformation stack.  
\item {\ttfamily obj.\-Pop ()} -\/ Deletes the transformation on the top of the stack and sets the top to the next transformation on the stack.  
\item {\ttfamily int = obj.\-Circuit\-Check (vtk\-Abstract\-Transform transform)} -\/ Check for self-\/reference. Will return true if concatenating with the specified transform, setting it to be our inverse, or setting it to be our input will create a circular reference. Circuit\-Check is automatically called by Set\-Input(), Set\-Inverse(), and Concatenate(vtk\-X\-Transform $\ast$). Avoid using this function, it is experimental.  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Get\-Inverse ()} -\/ Make a new transform of the same type.  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Make\-Transform ()} -\/ Make a new transform of the same type.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Override Get\-M\-Time to account for input and concatenation.  
\item {\ttfamily obj.\-Multiply\-Point (float in\mbox{[}4\mbox{]}, float out\mbox{[}4\mbox{]})} -\/ Use this method only if you wish to compute the transformation in homogeneous (x,y,z,w) coordinates, otherwise use Transform\-Point(). This method calls this-\/$>$Get\-Matrix()-\/$>$Multiply\-Point().  
\item {\ttfamily obj.\-Multiply\-Point (double in\mbox{[}4\mbox{]}, double out\mbox{[}4\mbox{]})} -\/ Use this method only if you wish to compute the transformation in homogeneous (x,y,z,w) coordinates, otherwise use Transform\-Point(). This method calls this-\/$>$Get\-Matrix()-\/$>$Multiply\-Point().  
\end{DoxyItemize}\hypertarget{vtkcommon_vtktransform2d}{}\section{vtk\-Transform2\-D}\label{vtkcommon_vtktransform2d}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
A vtk\-Transform2\-D can be used to describe the full range of linear (also known as affine) coordinate transformations in two dimensions, which are internally represented as a 3x3 homogeneous transformation matrix. When you create a new vtk\-Transform2\-D, it is always initialized to the identity transformation.

This class performs all of its operations in a right handed coordinate system with right handed rotations. Some other graphics libraries use left handed coordinate systems and rotations.

To create an instance of class vtk\-Transform2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTransform2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Transform2\-D has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Transform2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Transform2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Transform2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Identity ()} -\/ Set the transformation to the identity transformation.  
\item {\ttfamily obj.\-Inverse ()} -\/ Invert the transformation.  
\item {\ttfamily obj.\-Translate (double x, double y)} -\/ Create a translation matrix and concatenate it with the current transformation.  
\item {\ttfamily obj.\-Translate (double x\mbox{[}2\mbox{]})} -\/ Create a translation matrix and concatenate it with the current transformation.  
\item {\ttfamily obj.\-Translate (float x\mbox{[}2\mbox{]})} -\/ Create a rotation matrix and concatenate it with the current transformation. The angle is in degrees.  
\item {\ttfamily obj.\-Rotate (double angle)} -\/ Create a rotation matrix and concatenate it with the current transformation. The angle is in degrees.  
\item {\ttfamily obj.\-Scale (double x, double y)} -\/ Create a scale matrix (i.\-e. set the diagonal elements to x, y) and concatenate it with the current transformation.  
\item {\ttfamily obj.\-Scale (double s\mbox{[}2\mbox{]})} -\/ Create a scale matrix (i.\-e. set the diagonal elements to x, y) and concatenate it with the current transformation.  
\item {\ttfamily obj.\-Scale (float s\mbox{[}2\mbox{]})} -\/ Set the current matrix directly.  
\item {\ttfamily obj.\-Set\-Matrix (vtk\-Matrix3x3 matrix)} -\/ Set the current matrix directly.  
\item {\ttfamily obj.\-Set\-Matrix (double elements\mbox{[}9\mbox{]})} -\/ Set the current matrix directly.  
\item {\ttfamily vtk\-Matrix3x3 = obj.\-Get\-Matrix ()} -\/ Get the underlying 3x3 matrix.  
\item {\ttfamily obj.\-Get\-Matrix (vtk\-Matrix3x3 matrix)} -\/ Get the underlying 3x3 matrix.  
\item {\ttfamily obj.\-Get\-Position (double pos\mbox{[}2\mbox{]})} -\/ Return the position from the current transformation matrix as an array of two floating point numbers. This is simply returning the translation component of the 3x3 matrix.  
\item {\ttfamily obj.\-Get\-Position (float pos\mbox{[}2\mbox{]})} -\/ Return a matrix which is the inverse of the current transformation matrix.  
\item {\ttfamily obj.\-Get\-Inverse (vtk\-Matrix3x3 inverse)} -\/ Return a matrix which is the inverse of the current transformation matrix.  
\item {\ttfamily obj.\-Get\-Transpose (vtk\-Matrix3x3 transpose)} -\/ Return a matrix which is the transpose of the current transformation matrix. This is equivalent to the inverse if and only if the transformation is a pure rotation with no translation or scale.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Override Get\-M\-Time to account for input and concatenation.  
\item {\ttfamily obj.\-Transform\-Points (float in\-Pts, float out\-Pts, int n)} -\/ Apply the transformation to a series of points, and append the results to out\-Pts. Where n is the number of points, and the float pointers are of length 2$\ast$n.  
\item {\ttfamily obj.\-Transform\-Points (double in\-Pts, double out\-Pts, int n)} -\/ Apply the transformation to a series of points, and append the results to out\-Pts. Where n is the number of points, and the float pointers are of length 2$\ast$n.  
\item {\ttfamily obj.\-Transform\-Points (vtk\-Points2\-D in\-Pts, vtk\-Points2\-D out\-Pts)} -\/ Apply the transformation to a series of points, and append the results to out\-Pts.  
\item {\ttfamily obj.\-Inverse\-Transform\-Points (float in\-Pts, float out\-Pts, int n)} -\/ Apply the transformation to a series of points, and append the results to out\-Pts. Where n is the number of points, and the float pointers are of length 2$\ast$n.  
\item {\ttfamily obj.\-Inverse\-Transform\-Points (double in\-Pts, double out\-Pts, int n)} -\/ Apply the transformation to a series of points, and append the results to out\-Pts. Where n is the number of points, and the float pointers are of length 2$\ast$n.  
\item {\ttfamily obj.\-Inverse\-Transform\-Points (vtk\-Points2\-D in\-Pts, vtk\-Points2\-D out\-Pts)} -\/ Apply the transformation to a series of points, and append the results to out\-Pts.  
\item {\ttfamily obj.\-Multiply\-Point (float in\mbox{[}3\mbox{]}, float out\mbox{[}3\mbox{]})} -\/ Use this method only if you wish to compute the transformation in homogeneous (x,y,w) coordinates, otherwise use Transform\-Point(). This method calls this-\/$>$Get\-Matrix()-\/$>$Multiply\-Point().  
\item {\ttfamily obj.\-Multiply\-Point (double in\mbox{[}3\mbox{]}, double out\mbox{[}3\mbox{]})} -\/ Use this method only if you wish to compute the transformation in homogeneous (x,y,w) coordinates, otherwise use Transform\-Point(). This method calls this-\/$>$Get\-Matrix()-\/$>$Multiply\-Point().  
\end{DoxyItemize}\hypertarget{vtkcommon_vtktransformcollection}{}\section{vtk\-Transform\-Collection}\label{vtkcommon_vtktransformcollection}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Transform\-Collection is an object that creates and manipulates lists of objects of type vtk\-Transform.

To create an instance of class vtk\-Transform\-Collection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTransformCollection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Transform\-Collection has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Transform\-Collection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Transform\-Collection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Transform\-Collection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Item (vtk\-Transform )} -\/ Add a Transform to the list.  
\item {\ttfamily vtk\-Transform = obj.\-Get\-Next\-Item ()} -\/ Get the next Transform in the list. Return N\-U\-L\-L when the end of the list is reached.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtktypefloat32array}{}\section{vtk\-Type\-Float32\-Array}\label{vtkcommon_vtktypefloat32array}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Type\-Float32\-Array is an array of values of type vtk\-Type\-Float32. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Type\-Float32\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTypeFloat32Array
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Type\-Float32\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Type\-Float32\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Type\-Float32\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Type\-Float32\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtktypefloat64array}{}\section{vtk\-Type\-Float64\-Array}\label{vtkcommon_vtktypefloat64array}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Type\-Float64\-Array is an array of values of type vtk\-Type\-Float64. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Type\-Float64\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTypeFloat64Array
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Type\-Float64\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Type\-Float64\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Type\-Float64\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Type\-Float64\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtktypeint16array}{}\section{vtk\-Type\-Int16\-Array}\label{vtkcommon_vtktypeint16array}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Type\-Int16\-Array is an array of values of type vtk\-Type\-Int16. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Type\-Int16\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTypeInt16Array
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Type\-Int16\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Type\-Int16\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Type\-Int16\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Type\-Int16\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtktypeint32array}{}\section{vtk\-Type\-Int32\-Array}\label{vtkcommon_vtktypeint32array}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Type\-Int32\-Array is an array of values of type vtk\-Type\-Int32. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Type\-Int32\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTypeInt32Array
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Type\-Int32\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Type\-Int32\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Type\-Int32\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Type\-Int32\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtktypeint64array}{}\section{vtk\-Type\-Int64\-Array}\label{vtkcommon_vtktypeint64array}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Type\-Int64\-Array is an array of values of type vtk\-Type\-Int64. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Type\-Int64\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTypeInt64Array
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Type\-Int64\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Type\-Int64\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Type\-Int64\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Type\-Int64\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtktypeint8array}{}\section{vtk\-Type\-Int8\-Array}\label{vtkcommon_vtktypeint8array}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Type\-Int8\-Array is an array of values of type vtk\-Type\-Int8. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Type\-Int8\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTypeInt8Array
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Type\-Int8\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Type\-Int8\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Type\-Int8\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Type\-Int8\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtktypeuint16array}{}\section{vtk\-Type\-U\-Int16\-Array}\label{vtkcommon_vtktypeuint16array}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Type\-U\-Int16\-Array is an array of values of type vtk\-Type\-U\-Int16. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Type\-U\-Int16\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTypeUInt16Array
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Type\-U\-Int16\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Type\-U\-Int16\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Type\-U\-Int16\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Type\-U\-Int16\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtktypeuint32array}{}\section{vtk\-Type\-U\-Int32\-Array}\label{vtkcommon_vtktypeuint32array}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Type\-U\-Int32\-Array is an array of values of type vtk\-Type\-U\-Int32. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Type\-U\-Int32\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTypeUInt32Array
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Type\-U\-Int32\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Type\-U\-Int32\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Type\-U\-Int32\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Type\-U\-Int32\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtktypeuint64array}{}\section{vtk\-Type\-U\-Int64\-Array}\label{vtkcommon_vtktypeuint64array}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Type\-U\-Int64\-Array is an array of values of type vtk\-Type\-U\-Int64. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Type\-U\-Int64\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTypeUInt64Array
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Type\-U\-Int64\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Type\-U\-Int64\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Type\-U\-Int64\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Type\-U\-Int64\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtktypeuint8array}{}\section{vtk\-Type\-U\-Int8\-Array}\label{vtkcommon_vtktypeuint8array}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Type\-U\-Int8\-Array is an array of values of type vtk\-Type\-U\-Int8. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Type\-U\-Int8\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTypeUInt8Array
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Type\-U\-Int8\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Type\-U\-Int8\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Type\-U\-Int8\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Type\-U\-Int8\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkunicodestringarray}{}\section{vtk\-Unicode\-String\-Array}\label{vtkcommon_vtkunicodestringarray}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
.S\-E\-C\-T\-I\-O\-N Thanks Developed by Timothy M. Shead (\href{mailto:tshead@sandia.gov}{\tt tshead@sandia.\-gov}) at Sandia National Laboratories.

To create an instance of class vtk\-Unicode\-String\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkUnicodeStringArray
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Unicode\-String\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Unicode\-String\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Unicode\-String\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Unicode\-String\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Allocate (vtk\-Id\-Type sz, vtk\-Id\-Type ext)}  
\item {\ttfamily obj.\-Initialize ()}  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()}  
\item {\ttfamily int = obj.\-Get\-Data\-Type\-Size ()}  
\item {\ttfamily int = obj.\-Get\-Element\-Component\-Size ()}  
\item {\ttfamily obj.\-Set\-Number\-Of\-Tuples (vtk\-Id\-Type number)}  
\item {\ttfamily obj.\-Set\-Tuple (vtk\-Id\-Type i, vtk\-Id\-Type j, vtk\-Abstract\-Array source)}  
\item {\ttfamily obj.\-Insert\-Tuple (vtk\-Id\-Type i, vtk\-Id\-Type j, vtk\-Abstract\-Array source)}  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Tuple (vtk\-Id\-Type j, vtk\-Abstract\-Array source)}  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Abstract\-Array da)}  
\item {\ttfamily obj.\-Interpolate\-Tuple (vtk\-Id\-Type i, vtk\-Id\-List pt\-Indices, vtk\-Abstract\-Array source, double weights)}  
\item {\ttfamily obj.\-Interpolate\-Tuple (vtk\-Id\-Type i, vtk\-Id\-Type id1, vtk\-Abstract\-Array source1, vtk\-Id\-Type id2, vtk\-Abstract\-Array source2, double t)}  
\item {\ttfamily obj.\-Squeeze ()}  
\item {\ttfamily int = obj.\-Resize (vtk\-Id\-Type num\-Tuples)}  
\item {\ttfamily long = obj.\-Get\-Actual\-Memory\-Size ()}  
\item {\ttfamily int = obj.\-Is\-Numeric ()}  
\item {\ttfamily vtk\-Array\-Iterator = obj.\-New\-Iterator ()}  
\item {\ttfamily obj.\-Data\-Changed ()}  
\item {\ttfamily obj.\-Clear\-Lookup ()}  
\item {\ttfamily obj.\-Insert\-Next\-U\-T\-F8\-Value (string )}  
\item {\ttfamily obj.\-Set\-U\-T\-F8\-Value (vtk\-Id\-Type i, string )}  
\item {\ttfamily string = obj.\-Get\-U\-T\-F8\-Value (vtk\-Id\-Type i)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkunsignedchararray}{}\section{vtk\-Unsigned\-Char\-Array}\label{vtkcommon_vtkunsignedchararray}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Unsigned\-Char\-Array is an array of values of type unsigned char. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Unsigned\-Char\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkUnsignedCharArray
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Unsigned\-Char\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Unsigned\-Char\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Unsigned\-Char\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Unsigned\-Char\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()} -\/ Copy the tuple value into a user-\/provided array.  
\item {\ttfamily obj.\-Get\-Tuple\-Value (vtk\-Id\-Type i, string tuple)} -\/ Set the tuple value at the ith location in the array.  
\item {\ttfamily obj.\-Set\-Tuple\-Value (vtk\-Id\-Type i, string tuple)} -\/ Insert (memory allocation performed) the tuple into the ith location in the array.  
\item {\ttfamily obj.\-Insert\-Tuple\-Value (vtk\-Id\-Type i, string tuple)} -\/ Insert (memory allocation performed) the tuple onto the end of the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Tuple\-Value (string tuple)} -\/ Get the data at a particular index.  
\item {\ttfamily char = obj.\-Get\-Value (vtk\-Id\-Type id)} -\/ Set the data at a particular index. Does not do range checking. Make sure you use the method Set\-Number\-Of\-Values() before inserting data.  
\item {\ttfamily obj.\-Set\-Value (vtk\-Id\-Type id, char value)} -\/ Specify the number of values for this object to hold. Does an allocation as well as setting the Max\-Id ivar. Used in conjunction with Set\-Value() method for fast insertion.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Values (vtk\-Id\-Type number)} -\/ Insert data at a specified position in the array.  
\item {\ttfamily obj.\-Insert\-Value (vtk\-Id\-Type id, char f)} -\/ Insert data at the end of the array. Return its location in the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Value (char f)} -\/ Get the address of a particular data index. Make sure data is allocated for the number of items requested. Set Max\-Id according to the number of data values requested.  
\item {\ttfamily obj.\-Set\-Array (string array, vtk\-Id\-Type size, int save)} -\/ This method lets the user specify data to be held by the array. The array argument is a pointer to the data. size is the size of the array supplied by the user. Set save to 1 to keep the class from deleting the array when it cleans up or reallocates memory. The class uses the actual array provided; it does not copy the data from the suppled array.  
\item {\ttfamily obj.\-Set\-Array (string array, vtk\-Id\-Type size, int save, int delete\-Method)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkunsignedintarray}{}\section{vtk\-Unsigned\-Int\-Array}\label{vtkcommon_vtkunsignedintarray}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Unsigned\-Int\-Array is an array of values of type unsigned int. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Unsigned\-Int\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkUnsignedIntArray
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Unsigned\-Int\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Unsigned\-Int\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Unsigned\-Int\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Unsigned\-Int\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()} -\/ Copy the tuple value into a user-\/provided array.  
\item {\ttfamily obj.\-Get\-Tuple\-Value (vtk\-Id\-Type i, int tuple)} -\/ Set the tuple value at the ith location in the array.  
\item {\ttfamily obj.\-Set\-Tuple\-Value (vtk\-Id\-Type i, int tuple)} -\/ Insert (memory allocation performed) the tuple into the ith location in the array.  
\item {\ttfamily obj.\-Insert\-Tuple\-Value (vtk\-Id\-Type i, int tuple)} -\/ Insert (memory allocation performed) the tuple onto the end of the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Tuple\-Value (int tuple)} -\/ Get the data at a particular index.  
\item {\ttfamily int = obj.\-Get\-Value (vtk\-Id\-Type id)} -\/ Set the data at a particular index. Does not do range checking. Make sure you use the method Set\-Number\-Of\-Values() before inserting data.  
\item {\ttfamily obj.\-Set\-Value (vtk\-Id\-Type id, int value)} -\/ Specify the number of values for this object to hold. Does an allocation as well as setting the Max\-Id ivar. Used in conjunction with Set\-Value() method for fast insertion.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Values (vtk\-Id\-Type number)} -\/ Insert data at a specified position in the array.  
\item {\ttfamily obj.\-Insert\-Value (vtk\-Id\-Type id, int f)} -\/ Insert data at the end of the array. Return its location in the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Value (int f)} -\/ Get the address of a particular data index. Make sure data is allocated for the number of items requested. Set Max\-Id according to the number of data values requested.  
\item {\ttfamily obj.\-Set\-Array (int array, vtk\-Id\-Type size, int save)} -\/ This method lets the user specify data to be held by the array. The array argument is a pointer to the data. size is the size of the array supplied by the user. Set save to 1 to keep the class from deleting the array when it cleans up or reallocates memory. The class uses the actual array provided; it does not copy the data from the suppled array.  
\item {\ttfamily obj.\-Set\-Array (int array, vtk\-Id\-Type size, int save, int delete\-Method)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkunsignedlongarray}{}\section{vtk\-Unsigned\-Long\-Array}\label{vtkcommon_vtkunsignedlongarray}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Unsigned\-Long\-Array is an array of values of type unsigned long. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Unsigned\-Long\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkUnsignedLongArray
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Unsigned\-Long\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Unsigned\-Long\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Unsigned\-Long\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Unsigned\-Long\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()} -\/ Copy the tuple value into a user-\/provided array.  
\item {\ttfamily obj.\-Get\-Tuple\-Value (vtk\-Id\-Type i, long tuple)} -\/ Set the tuple value at the ith location in the array.  
\item {\ttfamily obj.\-Set\-Tuple\-Value (vtk\-Id\-Type i, long tuple)} -\/ Insert (memory allocation performed) the tuple into the ith location in the array.  
\item {\ttfamily obj.\-Insert\-Tuple\-Value (vtk\-Id\-Type i, long tuple)} -\/ Insert (memory allocation performed) the tuple onto the end of the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Tuple\-Value (long tuple)} -\/ Get the data at a particular index.  
\item {\ttfamily long = obj.\-Get\-Value (vtk\-Id\-Type id)} -\/ Set the data at a particular index. Does not do range checking. Make sure you use the method Set\-Number\-Of\-Values() before inserting data.  
\item {\ttfamily obj.\-Set\-Value (vtk\-Id\-Type id, long value)} -\/ Specify the number of values for this object to hold. Does an allocation as well as setting the Max\-Id ivar. Used in conjunction with Set\-Value() method for fast insertion.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Values (vtk\-Id\-Type number)} -\/ Insert data at a specified position in the array.  
\item {\ttfamily obj.\-Insert\-Value (vtk\-Id\-Type id, long f)} -\/ Insert data at the end of the array. Return its location in the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Value (long f)} -\/ Get the address of a particular data index. Make sure data is allocated for the number of items requested. Set Max\-Id according to the number of data values requested.  
\item {\ttfamily obj.\-Set\-Array (long array, vtk\-Id\-Type size, int save)} -\/ This method lets the user specify data to be held by the array. The array argument is a pointer to the data. size is the size of the array supplied by the user. Set save to 1 to keep the class from deleting the array when it cleans up or reallocates memory. The class uses the actual array provided; it does not copy the data from the suppled array.  
\item {\ttfamily obj.\-Set\-Array (long array, vtk\-Id\-Type size, int save, int delete\-Method)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkunsignedlonglongarray}{}\section{vtk\-Unsigned\-Long\-Long\-Array}\label{vtkcommon_vtkunsignedlonglongarray}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Unsigned\-Long\-Long\-Array is an array of values of type unsigned long long. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Unsigned\-Long\-Long\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkUnsignedLongLongArray
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Unsigned\-Long\-Long\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Unsigned\-Long\-Long\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Unsigned\-Long\-Long\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Unsigned\-Long\-Long\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()} -\/ Copy the tuple value into a user-\/provided array.  
\item {\ttfamily long = obj.\-long Get\-Value (vtk\-Id\-Type id)} -\/ Set the data at a particular index. Does not do range checking. Make sure you use the method Set\-Number\-Of\-Values() before inserting data.  
\item {\ttfamily obj.\-Set\-Value (vtk\-Id\-Type id, long long value)} -\/ Specify the number of values for this object to hold. Does an allocation as well as setting the Max\-Id ivar. Used in conjunction with Set\-Value() method for fast insertion.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Values (vtk\-Id\-Type number)} -\/ Insert data at a specified position in the array.  
\item {\ttfamily obj.\-Insert\-Value (vtk\-Id\-Type id, long long f)} -\/ Insert data at the end of the array. Return its location in the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Value (long long f)} -\/ Get the address of a particular data index. Make sure data is allocated for the number of items requested. Set Max\-Id according to the number of data values requested.  
\item {\ttfamily long = obj.\-long Write\-Pointer (vtk\-Id\-Type id, vtk\-Id\-Type number)} -\/ Get the address of a particular data index. Performs no checks to verify that the memory has been allocated etc.  
\item {\ttfamily long = obj.\-long Get\-Pointer (vtk\-Id\-Type id)} -\/ This method lets the user specify data to be held by the array. The array argument is a pointer to the data. size is the size of the array supplied by the user. Set save to 1 to keep the class from deleting the array when it cleans up or reallocates memory. The class uses the actual array provided; it does not copy the data from the suppled array.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkunsignedshortarray}{}\section{vtk\-Unsigned\-Short\-Array}\label{vtkcommon_vtkunsignedshortarray}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Unsigned\-Short\-Array is an array of values of type unsigned short. It provides methods for insertion and retrieval of values and will automatically resize itself to hold new data.

To create an instance of class vtk\-Unsigned\-Short\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkUnsignedShortArray
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Unsigned\-Short\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Unsigned\-Short\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Unsigned\-Short\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Unsigned\-Short\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()} -\/ Copy the tuple value into a user-\/provided array.  
\item {\ttfamily obj.\-Get\-Tuple\-Value (vtk\-Id\-Type i, short tuple)} -\/ Set the tuple value at the ith location in the array.  
\item {\ttfamily obj.\-Set\-Tuple\-Value (vtk\-Id\-Type i, short tuple)} -\/ Insert (memory allocation performed) the tuple into the ith location in the array.  
\item {\ttfamily obj.\-Insert\-Tuple\-Value (vtk\-Id\-Type i, short tuple)} -\/ Insert (memory allocation performed) the tuple onto the end of the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Tuple\-Value (short tuple)} -\/ Get the data at a particular index.  
\item {\ttfamily short = obj.\-Get\-Value (vtk\-Id\-Type id)} -\/ Set the data at a particular index. Does not do range checking. Make sure you use the method Set\-Number\-Of\-Values() before inserting data.  
\item {\ttfamily obj.\-Set\-Value (vtk\-Id\-Type id, short value)} -\/ Specify the number of values for this object to hold. Does an allocation as well as setting the Max\-Id ivar. Used in conjunction with Set\-Value() method for fast insertion.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Values (vtk\-Id\-Type number)} -\/ Insert data at a specified position in the array.  
\item {\ttfamily obj.\-Insert\-Value (vtk\-Id\-Type id, short f)} -\/ Insert data at the end of the array. Return its location in the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Value (short f)} -\/ Get the address of a particular data index. Make sure data is allocated for the number of items requested. Set Max\-Id according to the number of data values requested.  
\item {\ttfamily obj.\-Set\-Array (short array, vtk\-Id\-Type size, int save)} -\/ This method lets the user specify data to be held by the array. The array argument is a pointer to the data. size is the size of the array supplied by the user. Set save to 1 to keep the class from deleting the array when it cleans up or reallocates memory. The class uses the actual array provided; it does not copy the data from the suppled array.  
\item {\ttfamily obj.\-Set\-Array (short array, vtk\-Id\-Type size, int save, int delete\-Method)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkvariantarray}{}\section{vtk\-Variant\-Array}\label{vtkcommon_vtkvariantarray}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
.S\-E\-C\-T\-I\-O\-N Thanks Thanks to Patricia Crossno, Ken Moreland, Andrew Wilson and Brian Wylie from Sandia National Laboratories for their help in developing this class.

To create an instance of class vtk\-Variant\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVariantArray
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Variant\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Variant\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Variant\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Variant\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Allocate (vtk\-Id\-Type sz, vtk\-Id\-Type ext)} -\/ Allocate memory for this array. Delete old storage only if necessary. Note that ext is no longer used.  
\item {\ttfamily obj.\-Initialize ()} -\/ Release storage and reset array to initial state.  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()} -\/ Return the underlying data type. An integer indicating data type is returned as specified in vtk\-Set\-Get.\-h.  
\item {\ttfamily int = obj.\-Get\-Data\-Type\-Size ()} -\/ Return the size of the underlying data type. For a bit, 1 is returned. For string 0 is returned. Arrays with variable length components return 0.  
\item {\ttfamily int = obj.\-Get\-Element\-Component\-Size ()} -\/ Return the size, in bytes, of the lowest-\/level element of an array. For vtk\-Data\-Array and subclasses this is the size of the data type. For vtk\-String\-Array, this is sizeof(vtk\-Std\-String\-::value\-\_\-type), which winds up being sizeof(char).  
\item {\ttfamily obj.\-Set\-Number\-Of\-Tuples (vtk\-Id\-Type number)} -\/ Set the number of tuples (a component group) in the array. Note that this may allocate space depending on the number of components.  
\item {\ttfamily obj.\-Set\-Tuple (vtk\-Id\-Type i, vtk\-Id\-Type j, vtk\-Abstract\-Array source)} -\/ Set the tuple at the ith location using the jth tuple in the source array. This method assumes that the two arrays have the same type and structure. Note that range checking and memory allocation is not performed; use in conjunction with Set\-Number\-Of\-Tuples() to allocate space.  
\item {\ttfamily obj.\-Insert\-Tuple (vtk\-Id\-Type i, vtk\-Id\-Type j, vtk\-Abstract\-Array source)} -\/ Insert the jth tuple in the source array, at ith location in this array. Note that memory allocation is performed as necessary to hold the data.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Insert\-Next\-Tuple (vtk\-Id\-Type j, vtk\-Abstract\-Array source)} -\/ Insert the jth tuple in the source array, at the end in this array. Note that memory allocation is performed as necessary to hold the data. Returns the location at which the data was inserted.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Abstract\-Array da)} -\/ Deep copy of data. Implementation left to subclasses, which should support as many type conversions as possible given the data type.  
\item {\ttfamily obj.\-Interpolate\-Tuple (vtk\-Id\-Type i, vtk\-Id\-List pt\-Indices, vtk\-Abstract\-Array source, double weights)} -\/ Set the ith tuple in this array as the interpolated tuple value, given the pt\-Indices in the source array and associated interpolation weights. This method assumes that the two arrays are of the same type and strcuture.  
\item {\ttfamily obj.\-Interpolate\-Tuple (vtk\-Id\-Type i, vtk\-Id\-Type id1, vtk\-Abstract\-Array source1, vtk\-Id\-Type id2, vtk\-Abstract\-Array source2, double t)}  
\item {\ttfamily obj.\-Squeeze ()} -\/ Resize object to just fit data requirement. Reclaims extra memory.  
\item {\ttfamily int = obj.\-Resize (vtk\-Id\-Type num\-Tuples)} -\/ Resize the array while conserving the data. Returns 1 if resizing succeeded and 0 otherwise.  
\item {\ttfamily long = obj.\-Get\-Actual\-Memory\-Size ()} -\/ Return the memory in kilobytes consumed by this data array. Used to support streaming and reading/writing data. The value returned is guaranteed to be greater than or equal to the memory required to actually represent the data represented by this object. The information returned is valid only after the pipeline has been updated.  
\item {\ttfamily int = obj.\-Is\-Numeric ()} -\/ Since each item can be of a different type, we say that a variant array is not numeric.  
\item {\ttfamily vtk\-Array\-Iterator = obj.\-New\-Iterator ()} -\/ Subclasses must override this method and provide the right kind of templated vtk\-Array\-Iterator\-Template.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Values (vtk\-Id\-Type number)} -\/ Specify the number of values for this object to hold. Does an allocation as well as setting the Max\-Id ivar. Used in conjunction with Set\-Value() method for fast insertion.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Values ()} -\/ Tell the array explicitly that the data has changed. This is only necessary to call when you modify the array contents without using the array's A\-P\-I (i.\-e. you retrieve a pointer to the data and modify the array contents). You need to call this so that the fast lookup will know to rebuild itself. Otherwise, the lookup functions will give incorrect results.  
\item {\ttfamily obj.\-Data\-Changed ()} -\/ Tell the array explicitly that the data has changed. This is only necessary to call when you modify the array contents without using the array's A\-P\-I (i.\-e. you retrieve a pointer to the data and modify the array contents). You need to call this so that the fast lookup will know to rebuild itself. Otherwise, the lookup functions will give incorrect results.  
\item {\ttfamily obj.\-Data\-Element\-Changed (vtk\-Id\-Type id)} -\/ Tell the array explicitly that a single data element has changed. Like Data\-Changed(), then is only necessary when you modify the array contents without using the array's A\-P\-I.  
\item {\ttfamily obj.\-Clear\-Lookup ()} -\/ Delete the associated fast lookup data structure on this array, if it exists. The lookup will be rebuilt on the next call to a lookup function.  
\item {\ttfamily $\sim$vtk\-Variant\-Array = obj.()} -\/ This destructor is public to work around a bug in version 1.\-36.\-0 of the Boost.\-Serialization library.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkversion}{}\section{vtk\-Version}\label{vtkcommon_vtkversion}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Holds methods for defining/determining the current vtk version (major, minor, build).

To create an instance of class vtk\-Version, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVersion
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Version has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Version class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Version = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Version = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkvoidarray}{}\section{vtk\-Void\-Array}\label{vtkcommon_vtkvoidarray}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Void\-Array is an array of pointers to void. It provides methods for insertion and retrieval of these pointers values, and will automatically resize itself to hold new data.

To create an instance of class vtk\-Void\-Array, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVoidArray
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Void\-Array has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Void\-Array class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Void\-Array = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Void\-Array = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Allocate (vtk\-Id\-Type sz, vtk\-Id\-Type ext)} -\/ Allocate memory for this array. Delete old storage only if necessary. Note that the parameter ext is no longer used.  
\item {\ttfamily obj.\-Initialize ()} -\/ Release storage and reset array to initial state.  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()} -\/ Return the size of the data contained in the array.  
\item {\ttfamily int = obj.\-Get\-Data\-Type\-Size ()} -\/ Set the number of void$\ast$ pointers held in the array.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Pointers (vtk\-Id\-Type number)} -\/ Get the number of void$\ast$ pointers held in the array.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Pointers ()} -\/ Get the void$\ast$ pointer at the ith location.  
\item {\ttfamily obj.\-Reset ()} -\/ Resize the array to just fit the inserted memory. Reclaims extra memory.  
\item {\ttfamily obj.\-Squeeze ()} -\/ Get the address of a particular data index. Performs no checks to verify that the memory has been allocated etc.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Void\-Array va)} -\/ Deep copy of another void array.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkwarptransform}{}\section{vtk\-Warp\-Transform}\label{vtkcommon_vtkwarptransform}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Warp\-Transform provides a generic interface for nonlinear warp transformations.

To create an instance of class vtk\-Warp\-Transform, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkWarpTransform
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Warp\-Transform has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Warp\-Transform class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Warp\-Transform = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Warp\-Transform = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Inverse ()} -\/ Invert the transformation. Warp transformations are usually inverted using an iterative technique such as Newton's method. The inverse transform is usually around five or six times as computationally expensive as the forward transform.  
\item {\ttfamily int = obj.\-Get\-Inverse\-Flag ()} -\/ Get the inverse flag of the transformation. This flag is set to zero when the transformation is first created, and is flipped each time Inverse() is called.  
\item {\ttfamily obj.\-Set\-Inverse\-Tolerance (double )} -\/ Set the tolerance for inverse transformation. The default is 0.\-001.  
\item {\ttfamily double = obj.\-Get\-Inverse\-Tolerance ()} -\/ Set the tolerance for inverse transformation. The default is 0.\-001.  
\item {\ttfamily obj.\-Set\-Inverse\-Iterations (int )} -\/ Set the maximum number of iterations for the inverse transformation. The default is 500, but usually only 2 to 5 iterations are used. The inversion method is fairly robust, and it should converge for nearly all smooth transformations that do not fold back on themselves.  
\item {\ttfamily int = obj.\-Get\-Inverse\-Iterations ()} -\/ Set the maximum number of iterations for the inverse transformation. The default is 500, but usually only 2 to 5 iterations are used. The inversion method is fairly robust, and it should converge for nearly all smooth transformations that do not fold back on themselves.  
\item {\ttfamily obj.\-Internal\-Transform\-Point (float in\mbox{[}3\mbox{]}, float out\mbox{[}3\mbox{]})} -\/ This will calculate the transformation without calling Update. Meant for use only within other V\-T\-K classes.  
\item {\ttfamily obj.\-Internal\-Transform\-Point (double in\mbox{[}3\mbox{]}, double out\mbox{[}3\mbox{]})} -\/ This will calculate the transformation without calling Update. Meant for use only within other V\-T\-K classes.  
\item {\ttfamily obj.\-Template\-Transform\-Point (float in\mbox{[}3\mbox{]}, float out\mbox{[}3\mbox{]})} -\/ Do not use these methods. They exists only as a work-\/around for internal templated functions (I really didn't want to make the Forward/\-Inverse methods public, is there a decent work around for this sort of thing?)  
\item {\ttfamily obj.\-Template\-Transform\-Point (double in\mbox{[}3\mbox{]}, double out\mbox{[}3\mbox{]})} -\/ Do not use these methods. They exists only as a work-\/around for internal templated functions (I really didn't want to make the Forward/\-Inverse methods public, is there a decent work around for this sort of thing?)  
\item {\ttfamily obj.\-Template\-Transform\-Inverse (float in\mbox{[}3\mbox{]}, float out\mbox{[}3\mbox{]})} -\/ Do not use these methods. They exists only as a work-\/around for internal templated functions (I really didn't want to make the Forward/\-Inverse methods public, is there a decent work around for this sort of thing?)  
\item {\ttfamily obj.\-Template\-Transform\-Inverse (double in\mbox{[}3\mbox{]}, double out\mbox{[}3\mbox{]})} -\/ Do not use these methods. They exists only as a work-\/around for internal templated functions (I really didn't want to make the Forward/\-Inverse methods public, is there a decent work around for this sort of thing?)  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkwindow}{}\section{vtk\-Window}\label{vtkcommon_vtkwindow}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Window is an abstract object to specify the behavior of a rendering window. It contains vtk\-Viewports.

To create an instance of class vtk\-Window, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkWindow
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Window has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Window class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Window = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Window = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Window\-Info (string )} -\/ These are window system independent methods that are used to help interface vtk\-Window to native windowing systems.  
\item {\ttfamily obj.\-Set\-Parent\-Info (string )} -\/ These are window system independent methods that are used to help interface vtk\-Window to native windowing systems.  
\item {\ttfamily int = obj.\-Get\-Position ()} -\/ Set/\-Get the position in screen coordinates of the rendering window.  
\item {\ttfamily obj.\-Set\-Position (int , int )} -\/ Set/\-Get the position in screen coordinates of the rendering window.  
\item {\ttfamily obj.\-Set\-Position (int a\mbox{[}2\mbox{]})} -\/ Set/\-Get the position in screen coordinates of the rendering window.  
\item {\ttfamily int = obj.\-Get\-Size ()} -\/ Set/\-Get the size of the window in screen coordinates in pixels.  
\item {\ttfamily obj.\-Set\-Size (int , int )} -\/ Set/\-Get the size of the window in screen coordinates in pixels.  
\item {\ttfamily obj.\-Set\-Size (int a\mbox{[}2\mbox{]})} -\/ Set/\-Get the size of the window in screen coordinates in pixels.  
\item {\ttfamily obj.\-Set\-Mapped (int )} -\/ Keep track of whether the rendering window has been mapped to screen.  
\item {\ttfamily int = obj.\-Get\-Mapped ()} -\/ Keep track of whether the rendering window has been mapped to screen.  
\item {\ttfamily obj.\-Mapped\-On ()} -\/ Keep track of whether the rendering window has been mapped to screen.  
\item {\ttfamily obj.\-Mapped\-Off ()} -\/ Keep track of whether the rendering window has been mapped to screen.  
\item {\ttfamily obj.\-Set\-Erase (int )} -\/ Turn on/off erasing the screen between images. This allows multiple exposure sequences if turned on. You will need to turn double buffering off or make use of the Swap\-Buffers methods to prevent you from swapping buffers between exposures.  
\item {\ttfamily int = obj.\-Get\-Erase ()} -\/ Turn on/off erasing the screen between images. This allows multiple exposure sequences if turned on. You will need to turn double buffering off or make use of the Swap\-Buffers methods to prevent you from swapping buffers between exposures.  
\item {\ttfamily obj.\-Erase\-On ()} -\/ Turn on/off erasing the screen between images. This allows multiple exposure sequences if turned on. You will need to turn double buffering off or make use of the Swap\-Buffers methods to prevent you from swapping buffers between exposures.  
\item {\ttfamily obj.\-Erase\-Off ()} -\/ Turn on/off erasing the screen between images. This allows multiple exposure sequences if turned on. You will need to turn double buffering off or make use of the Swap\-Buffers methods to prevent you from swapping buffers between exposures.  
\item {\ttfamily obj.\-Set\-Double\-Buffer (int )} -\/ Keep track of whether double buffering is on or off  
\item {\ttfamily int = obj.\-Get\-Double\-Buffer ()} -\/ Keep track of whether double buffering is on or off  
\item {\ttfamily obj.\-Double\-Buffer\-On ()} -\/ Keep track of whether double buffering is on or off  
\item {\ttfamily obj.\-Double\-Buffer\-Off ()} -\/ Keep track of whether double buffering is on or off  
\item {\ttfamily string = obj.\-Get\-Window\-Name ()} -\/ Get name of rendering window  
\item {\ttfamily obj.\-Set\-Window\-Name (string )} -\/ Get name of rendering window  
\item {\ttfamily obj.\-Render ()} -\/ Ask each viewport owned by this Window to render its image and synchronize this process.  
\item {\ttfamily int = obj.\-Get\-Pixel\-Data (int x, int y, int x2, int y2, int front, vtk\-Unsigned\-Char\-Array data)} -\/ Get the pixel data of an image, transmitted as R\-G\-B\-R\-G\-B\-R\-G\-B. The front argument indicates if the front buffer should be used or the back buffer. It is the caller's responsibility to delete the resulting array. It is very important to realize that the memory in this array is organized from the bottom of the window to the top. The origin of the screen is in the lower left corner. The y axis increases as you go up the screen. So the storage of pixels is from left to right and from bottom to top. (x,y) is any corner of the rectangle. (x2,y2) is its opposite corner on the diagonal.  
\item {\ttfamily int = obj.\-Get\-D\-P\-I ()} -\/ Return a best estimate to the dots per inch of the display device being rendered (or printed).  
\item {\ttfamily obj.\-Set\-D\-P\-I (int )} -\/ Return a best estimate to the dots per inch of the display device being rendered (or printed).  
\item {\ttfamily int = obj.\-Get\-D\-P\-I\-Min\-Value ()} -\/ Return a best estimate to the dots per inch of the display device being rendered (or printed).  
\item {\ttfamily int = obj.\-Get\-D\-P\-I\-Max\-Value ()} -\/ Return a best estimate to the dots per inch of the display device being rendered (or printed).  
\item {\ttfamily obj.\-Set\-Off\-Screen\-Rendering (int )} -\/ Create a window in memory instead of on the screen. This may not be supported for every type of window and on some windows you may need to invoke this prior to the first render.  
\item {\ttfamily int = obj.\-Get\-Off\-Screen\-Rendering ()} -\/ Create a window in memory instead of on the screen. This may not be supported for every type of window and on some windows you may need to invoke this prior to the first render.  
\item {\ttfamily obj.\-Off\-Screen\-Rendering\-On ()} -\/ Create a window in memory instead of on the screen. This may not be supported for every type of window and on some windows you may need to invoke this prior to the first render.  
\item {\ttfamily obj.\-Off\-Screen\-Rendering\-Off ()} -\/ Create a window in memory instead of on the screen. This may not be supported for every type of window and on some windows you may need to invoke this prior to the first render.  
\item {\ttfamily obj.\-Make\-Current ()} -\/ Make the window current. May be overridden in subclasses to do for example a gl\-X\-Make\-Current or a wgl\-Make\-Current.  
\item {\ttfamily obj.\-Set\-Tile\-Scale (int , int )} -\/ These methods are used by vtk\-Window\-To\-Image\-Filter to tell a V\-T\-K window to simulate a larger window by tiling. For 3\-D geometry these methods have no impact. It is just in handling annotation that this information must be available to the mappers and the coordinate calculations.  
\item {\ttfamily obj.\-Set\-Tile\-Scale (int a\mbox{[}2\mbox{]})} -\/ These methods are used by vtk\-Window\-To\-Image\-Filter to tell a V\-T\-K window to simulate a larger window by tiling. For 3\-D geometry these methods have no impact. It is just in handling annotation that this information must be available to the mappers and the coordinate calculations.  
\item {\ttfamily int = obj. Get\-Tile\-Scale ()} -\/ These methods are used by vtk\-Window\-To\-Image\-Filter to tell a V\-T\-K window to simulate a larger window by tiling. For 3\-D geometry these methods have no impact. It is just in handling annotation that this information must be available to the mappers and the coordinate calculations.  
\item {\ttfamily obj.\-Set\-Tile\-Scale (int s)} -\/ These methods are used by vtk\-Window\-To\-Image\-Filter to tell a V\-T\-K window to simulate a larger window by tiling. For 3\-D geometry these methods have no impact. It is just in handling annotation that this information must be available to the mappers and the coordinate calculations.  
\item {\ttfamily obj.\-Set\-Tile\-Viewport (double , double , double , double )} -\/ These methods are used by vtk\-Window\-To\-Image\-Filter to tell a V\-T\-K window to simulate a larger window by tiling. For 3\-D geometry these methods have no impact. It is just in handling annotation that this information must be available to the mappers and the coordinate calculations.  
\item {\ttfamily obj.\-Set\-Tile\-Viewport (double a\mbox{[}4\mbox{]})} -\/ These methods are used by vtk\-Window\-To\-Image\-Filter to tell a V\-T\-K window to simulate a larger window by tiling. For 3\-D geometry these methods have no impact. It is just in handling annotation that this information must be available to the mappers and the coordinate calculations.  
\item {\ttfamily double = obj. Get\-Tile\-Viewport ()} -\/ These methods are used by vtk\-Window\-To\-Image\-Filter to tell a V\-T\-K window to simulate a larger window by tiling. For 3\-D geometry these methods have no impact. It is just in handling annotation that this information must be available to the mappers and the coordinate calculations.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkwindowlevellookuptable}{}\section{vtk\-Window\-Level\-Lookup\-Table}\label{vtkcommon_vtkwindowlevellookuptable}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Window\-Level\-Lookup\-Table is an object that is used by mapper objects to map scalar values into rgba (red-\/green-\/blue-\/alpha transparency) color specification, or rgba into scalar values. The color table can be created by direct insertion of color values, or by specifying a window and level. Window / Level is used in medical imaging to specify a linear greyscale ramp. The Level is the center of the ramp. The Window is the width of the ramp.

To create an instance of class vtk\-Window\-Level\-Lookup\-Table, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkWindowLevelLookupTable
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Window\-Level\-Lookup\-Table has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Window\-Level\-Lookup\-Table class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Window\-Level\-Lookup\-Table = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Window\-Level\-Lookup\-Table = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Build ()} -\/ Generate lookup table as a linear ramp between Minimum\-Table\-Value and Maximum\-Table\-Value.  
\item {\ttfamily obj.\-Set\-Window (double window)} -\/ Set the window for the lookup table. The window is the difference between Table\-Range\mbox{[}0\mbox{]} and Table\-Range\mbox{[}1\mbox{]}.  
\item {\ttfamily double = obj.\-Get\-Window ()} -\/ Set the window for the lookup table. The window is the difference between Table\-Range\mbox{[}0\mbox{]} and Table\-Range\mbox{[}1\mbox{]}.  
\item {\ttfamily obj.\-Set\-Level (double level)} -\/ Set the Level for the lookup table. The level is the average of Table\-Range\mbox{[}0\mbox{]} and Table\-Range\mbox{[}1\mbox{]}.  
\item {\ttfamily double = obj.\-Get\-Level ()} -\/ Set the Level for the lookup table. The level is the average of Table\-Range\mbox{[}0\mbox{]} and Table\-Range\mbox{[}1\mbox{]}.  
\item {\ttfamily obj.\-Set\-Inverse\-Video (int iv)} -\/ Set inverse video on or off. You can achieve the same effect by switching the Minimum\-Table\-Value and the Maximum\-Table\-Value.  
\item {\ttfamily int = obj.\-Get\-Inverse\-Video ()} -\/ Set inverse video on or off. You can achieve the same effect by switching the Minimum\-Table\-Value and the Maximum\-Table\-Value.  
\item {\ttfamily obj.\-Inverse\-Video\-On ()} -\/ Set inverse video on or off. You can achieve the same effect by switching the Minimum\-Table\-Value and the Maximum\-Table\-Value.  
\item {\ttfamily obj.\-Inverse\-Video\-Off ()} -\/ Set inverse video on or off. You can achieve the same effect by switching the Minimum\-Table\-Value and the Maximum\-Table\-Value.  
\item {\ttfamily obj.\-Set\-Minimum\-Table\-Value (double , double , double , double )} -\/ Set the minimum table value. All lookup table entries below the start of the ramp will be set to this color. After you change this value, you must re-\/build the lookup table.  
\item {\ttfamily obj.\-Set\-Minimum\-Table\-Value (double a\mbox{[}4\mbox{]})} -\/ Set the minimum table value. All lookup table entries below the start of the ramp will be set to this color. After you change this value, you must re-\/build the lookup table.  
\item {\ttfamily double = obj. Get\-Minimum\-Table\-Value ()} -\/ Set the minimum table value. All lookup table entries below the start of the ramp will be set to this color. After you change this value, you must re-\/build the lookup table.  
\item {\ttfamily obj.\-Set\-Maximum\-Table\-Value (double , double , double , double )} -\/ Set the maximum table value. All lookup table entries above the end of the ramp will be set to this color. After you change this value, you must re-\/build the lookup table.  
\item {\ttfamily obj.\-Set\-Maximum\-Table\-Value (double a\mbox{[}4\mbox{]})} -\/ Set the maximum table value. All lookup table entries above the end of the ramp will be set to this color. After you change this value, you must re-\/build the lookup table.  
\item {\ttfamily double = obj. Get\-Maximum\-Table\-Value ()} -\/ Set the maximum table value. All lookup table entries above the end of the ramp will be set to this color. After you change this value, you must re-\/build the lookup table.  
\item {\ttfamily obj.\-Set\-Minimum\-Color (int r, int g, int b, int a)} -\/  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkxmldataelement}{}\section{vtk\-X\-M\-L\-Data\-Element}\label{vtkcommon_vtkxmldataelement}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Data\-Element is used by vtk\-X\-M\-L\-Data\-Parser to represent an X\-M\-L element. It provides methods to access the element's attributes and nested elements in a convenient manner. This allows easy traversal of an input X\-M\-L file by vtk\-X\-M\-L\-Reader and its subclasses.

To create an instance of class vtk\-X\-M\-L\-Data\-Element, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLDataElement
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Data\-Element has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-X\-M\-L\-Data\-Element class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Data\-Element = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Data\-Element = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily string = obj.\-Get\-Name ()} -\/ Set/\-Get the name of the element. This is its X\-M\-L tag.  
\item {\ttfamily obj.\-Set\-Name (string \-\_\-arg)} -\/ Set/\-Get the name of the element. This is its X\-M\-L tag.  
\item {\ttfamily string = obj.\-Get\-Id ()} -\/ Set/\-Get the value of the id attribute of the element, if any.  
\item {\ttfamily obj.\-Set\-Id (string )} -\/ Set/\-Get the value of the id attribute of the element, if any.  
\item {\ttfamily string = obj.\-Get\-Attribute (string name)} -\/ Get the attribute with the given name. If it doesn't exist, returns 0.  
\item {\ttfamily obj.\-Set\-Attribute (string name, string value)} -\/ Set the attribute with the given name and value. If it doesn't exist, adds it.  
\item {\ttfamily obj.\-Set\-Character\-Data (string c, int length)} -\/ Set/\-Get the character data between X\-M\-L start/end tags.  
\item {\ttfamily string = obj.\-Get\-Character\-Data ()} -\/ Set/\-Get the character data between X\-M\-L start/end tags.  
\item {\ttfamily obj.\-Set\-Int\-Attribute (string name, int value)} -\/ Set the attribute with the given name. We can not use the same Get\-Scalar\-Attribute() construct since the compiler will not be able to resolve between Set\-Attribute(..., int) and Set\-Attribute(..., unsigned long).  
\item {\ttfamily obj.\-Set\-Float\-Attribute (string name, float value)} -\/ Set the attribute with the given name. We can not use the same Get\-Scalar\-Attribute() construct since the compiler will not be able to resolve between Set\-Attribute(..., int) and Set\-Attribute(..., unsigned long).  
\item {\ttfamily obj.\-Set\-Double\-Attribute (string name, double value)} -\/ Set the attribute with the given name. We can not use the same Get\-Scalar\-Attribute() construct since the compiler will not be able to resolve between Set\-Attribute(..., int) and Set\-Attribute(..., unsigned long).  
\item {\ttfamily obj.\-Set\-Unsigned\-Long\-Attribute (string name, long value)} -\/ Set the attribute with the given name. We can not use the same Get\-Scalar\-Attribute() construct since the compiler will not be able to resolve between Set\-Attribute(..., int) and Set\-Attribute(..., unsigned long).  
\item {\ttfamily int = obj.\-Get\-Vector\-Attribute (string name, int length, int value)} -\/ Get the attribute with the given name and converted to a scalar value. Returns length of vector read.  
\item {\ttfamily int = obj.\-Get\-Vector\-Attribute (string name, int length, float value)} -\/ Get the attribute with the given name and converted to a scalar value. Returns length of vector read.  
\item {\ttfamily int = obj.\-Get\-Vector\-Attribute (string name, int length, double value)} -\/ Get the attribute with the given name and converted to a scalar value. Returns length of vector read.  
\item {\ttfamily int = obj.\-Get\-Vector\-Attribute (string name, int length, long value)} -\/ Get the attribute with the given name and converted to a scalar value. Returns length of vector read.  
\item {\ttfamily obj.\-Set\-Vector\-Attribute (string name, int length, int value)} -\/ Set the attribute with the given name.  
\item {\ttfamily obj.\-Set\-Vector\-Attribute (string name, int length, float value)} -\/ Set the attribute with the given name.  
\item {\ttfamily obj.\-Set\-Vector\-Attribute (string name, int length, double value)} -\/ Set the attribute with the given name.  
\item {\ttfamily obj.\-Set\-Vector\-Attribute (string name, int length, long value)} -\/ Set the attribute with the given name.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Attributes ()} -\/ Get the number of attributes.  
\item {\ttfamily string = obj.\-Get\-Attribute\-Name (int idx)} -\/ Get the n-\/th attribute name. Returns 0 if there is no such attribute.  
\item {\ttfamily string = obj.\-Get\-Attribute\-Value (int idx)} -\/ Get the n-\/th attribute value. Returns 0 if there is no such attribute.  
\item {\ttfamily obj.\-Remove\-Attribute (string name)} -\/ Remove one or all attributes.  
\item {\ttfamily obj.\-Remove\-All\-Attributes ()} -\/ Remove one or all attributes.  
\item {\ttfamily vtk\-X\-M\-L\-Data\-Element = obj.\-Get\-Parent ()} -\/ Set/\-Get the parent of this element.  
\item {\ttfamily obj.\-Set\-Parent (vtk\-X\-M\-L\-Data\-Element parent)} -\/ Set/\-Get the parent of this element.  
\item {\ttfamily vtk\-X\-M\-L\-Data\-Element = obj.\-Get\-Root ()} -\/ Get root of the X\-M\-L tree this element is part of.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Nested\-Elements ()} -\/ Get the number of elements nested in this one.  
\item {\ttfamily vtk\-X\-M\-L\-Data\-Element = obj.\-Get\-Nested\-Element (int index)} -\/ Get the element nested in this one at the given index.  
\item {\ttfamily obj.\-Add\-Nested\-Element (vtk\-X\-M\-L\-Data\-Element element)} -\/ Add nested element  
\item {\ttfamily obj.\-Remove\-Nested\-Element (vtk\-X\-M\-L\-Data\-Element )} -\/ Remove nested element.  
\item {\ttfamily obj.\-Remove\-All\-Nested\-Elements ()} -\/ Remove all nested elements.  
\item {\ttfamily vtk\-X\-M\-L\-Data\-Element = obj.\-Find\-Nested\-Element (string id)} -\/ Find the first nested element with the given id, given name, or given name and id. W\-A\-R\-N\-I\-N\-G\-: the search is only performed on the children, not the grand-\/children.  
\item {\ttfamily vtk\-X\-M\-L\-Data\-Element = obj.\-Find\-Nested\-Element\-With\-Name (string name)} -\/ Find the first nested element with the given id, given name, or given name and id. W\-A\-R\-N\-I\-N\-G\-: the search is only performed on the children, not the grand-\/children.  
\item {\ttfamily vtk\-X\-M\-L\-Data\-Element = obj.\-Find\-Nested\-Element\-With\-Name\-And\-Id (string name, string id)} -\/ Find the first nested element with the given id, given name, or given name and id. W\-A\-R\-N\-I\-N\-G\-: the search is only performed on the children, not the grand-\/children.  
\item {\ttfamily vtk\-X\-M\-L\-Data\-Element = obj.\-Find\-Nested\-Element\-With\-Name\-And\-Attribute (string name, string att\-\_\-name, string att\-\_\-value)} -\/ Find the first nested element with the given id, given name, or given name and id. W\-A\-R\-N\-I\-N\-G\-: the search is only performed on the children, not the grand-\/children.  
\item {\ttfamily vtk\-X\-M\-L\-Data\-Element = obj.\-Lookup\-Element\-With\-Name (string name)} -\/ Find the first nested element with given name. W\-A\-R\-N\-I\-N\-G\-: the search is performed on the whole X\-M\-L tree.  
\item {\ttfamily vtk\-X\-M\-L\-Data\-Element = obj.\-Lookup\-Element (string id)} -\/ Lookup the element with the given id, starting at this scope.  
\item {\ttfamily long = obj.\-Get\-X\-M\-L\-Byte\-Index ()} -\/ Set/\-Get the offset from the beginning of the X\-M\-L document to this element.  
\item {\ttfamily obj.\-Set\-X\-M\-L\-Byte\-Index (long )} -\/ Set/\-Get the offset from the beginning of the X\-M\-L document to this element.  
\item {\ttfamily int = obj.\-Is\-Equal\-To (vtk\-X\-M\-L\-Data\-Element elem)} -\/ Check if the instance has the same name, attributes, character data and nested elements contents than the given element (this method is applied recursively on the nested elements, and they must be stored in the same order). Warning\-: Id, Parent, X\-M\-L\-Byte\-Index are ignored.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-X\-M\-L\-Data\-Element elem)} -\/ Copy this element from another of the same type (elem), recursively. Old attributes and nested elements are removed, new ones are created given the contents of 'elem'. Warning\-: Parent is ignored.  
\item {\ttfamily obj.\-Set\-Attribute\-Encoding (int )} -\/ Get/\-Set the internal character encoding of the attributes. Default type is V\-T\-K\-\_\-\-E\-N\-C\-O\-D\-I\-N\-G\-\_\-\-U\-T\-F\-\_\-8. Note that a vtk\-X\-M\-L\-Data\-Parser has its own Attributes\-Encoding ivar. If this ivar is set to something other than V\-T\-K\-\_\-\-E\-N\-C\-O\-D\-I\-N\-G\-\_\-\-N\-O\-N\-E, it will be used to set the attribute encoding of each vtk\-X\-M\-L\-Data\-Element created by this vtk\-X\-M\-L\-Data\-Parser.  
\item {\ttfamily int = obj.\-Get\-Attribute\-Encoding\-Min\-Value ()} -\/ Get/\-Set the internal character encoding of the attributes. Default type is V\-T\-K\-\_\-\-E\-N\-C\-O\-D\-I\-N\-G\-\_\-\-U\-T\-F\-\_\-8. Note that a vtk\-X\-M\-L\-Data\-Parser has its own Attributes\-Encoding ivar. If this ivar is set to something other than V\-T\-K\-\_\-\-E\-N\-C\-O\-D\-I\-N\-G\-\_\-\-N\-O\-N\-E, it will be used to set the attribute encoding of each vtk\-X\-M\-L\-Data\-Element created by this vtk\-X\-M\-L\-Data\-Parser.  
\item {\ttfamily int = obj.\-Get\-Attribute\-Encoding\-Max\-Value ()} -\/ Get/\-Set the internal character encoding of the attributes. Default type is V\-T\-K\-\_\-\-E\-N\-C\-O\-D\-I\-N\-G\-\_\-\-U\-T\-F\-\_\-8. Note that a vtk\-X\-M\-L\-Data\-Parser has its own Attributes\-Encoding ivar. If this ivar is set to something other than V\-T\-K\-\_\-\-E\-N\-C\-O\-D\-I\-N\-G\-\_\-\-N\-O\-N\-E, it will be used to set the attribute encoding of each vtk\-X\-M\-L\-Data\-Element created by this vtk\-X\-M\-L\-Data\-Parser.  
\item {\ttfamily int = obj.\-Get\-Attribute\-Encoding ()} -\/ Get/\-Set the internal character encoding of the attributes. Default type is V\-T\-K\-\_\-\-E\-N\-C\-O\-D\-I\-N\-G\-\_\-\-U\-T\-F\-\_\-8. Note that a vtk\-X\-M\-L\-Data\-Parser has its own Attributes\-Encoding ivar. If this ivar is set to something other than V\-T\-K\-\_\-\-E\-N\-C\-O\-D\-I\-N\-G\-\_\-\-N\-O\-N\-E, it will be used to set the attribute encoding of each vtk\-X\-M\-L\-Data\-Element created by this vtk\-X\-M\-L\-Data\-Parser.  
\item {\ttfamily obj.\-Print\-X\-M\-L (string fname)} -\/ Prints element tree as X\-M\-L.  
\item {\ttfamily int = obj.\-Get\-Character\-Data\-Width ()} -\/ Get/\-Set the width (in number of fields) that character data (that between open and closing tags ie. $<$\-X$>$ ... $<$/\-X$>$) is printed. If the width is less than one the tag's character data is printed all on one line. If it is greater than one the character data is streamed insterting line feeds every width number of fields. See Print\-X\-M\-L.  
\item {\ttfamily obj.\-Set\-Character\-Data\-Width (int )} -\/ Get/\-Set the width (in number of fields) that character data (that between open and closing tags ie. $<$\-X$>$ ... $<$/\-X$>$) is printed. If the width is less than one the tag's character data is printed all on one line. If it is greater than one the character data is streamed insterting line feeds every width number of fields. See Print\-X\-M\-L.  
\end{DoxyItemize}\hypertarget{vtkcommon_vtkxmlfileoutputwindow}{}\section{vtk\-X\-M\-L\-File\-Output\-Window}\label{vtkcommon_vtkxmlfileoutputwindow}
Section\-: \hyperlink{sec_vtkcommon}{Visualization Toolkit Common Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Writes debug/warning/error output to an X\-M\-L file. Uses prefined X\-M\-L tags for each text display method. The text is processed to replace X\-M\-L markup characters.

Display\-Text -\/ $<$\-Text$>$

Display\-Error\-Text -\/ $<$\-Error$>$

Display\-Warning\-Text -\/ $<$\-Warning$>$

Display\-Generic\-Warning\-Text -\/ $<$\-Generic\-Warning$>$

Display\-Debug\-Text -\/ $<$\-Debug$>$

The method Display\-Tag outputs the text unprocessed. To use this class, instantiate it and then call Set\-Instance(this).

To create an instance of class vtk\-X\-M\-L\-File\-Output\-Window, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLFileOutputWindow
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-File\-Output\-Window has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-X\-M\-L\-File\-Output\-Window class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-File\-Output\-Window = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-File\-Output\-Window = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Display\-Text (string )} -\/ Put the text into the log file. The text is processed to replace \&, $<$, $>$ with \&amp, \&lt, and \&gt. Each display method outputs a different X\-M\-L tag.  
\item {\ttfamily obj.\-Display\-Error\-Text (string )} -\/ Put the text into the log file. The text is processed to replace \&, $<$, $>$ with \&amp, \&lt, and \&gt. Each display method outputs a different X\-M\-L tag.  
\item {\ttfamily obj.\-Display\-Warning\-Text (string )} -\/ Put the text into the log file. The text is processed to replace \&, $<$, $>$ with \&amp, \&lt, and \&gt. Each display method outputs a different X\-M\-L tag.  
\item {\ttfamily obj.\-Display\-Generic\-Warning\-Text (string )} -\/ Put the text into the log file. The text is processed to replace \&, $<$, $>$ with \&amp, \&lt, and \&gt. Each display method outputs a different X\-M\-L tag.  
\item {\ttfamily obj.\-Display\-Debug\-Text (string )} -\/ Put the text into the log file. The text is processed to replace \&, $<$, $>$ with \&amp, \&lt, and \&gt. Each display method outputs a different X\-M\-L tag.  
\item {\ttfamily obj.\-Display\-Tag (string )} -\/ Put the text into the log file without processing it.  
\end{DoxyItemize}