
\begin{DoxyItemize}
\item \hyperlink{vtkio_vtkabstractparticlewriter}{vtk\-Abstract\-Particle\-Writer}  
\item \hyperlink{vtkio_vtkarrayreader}{vtk\-Array\-Reader}  
\item \hyperlink{vtkio_vtkarraywriter}{vtk\-Array\-Writer}  
\item \hyperlink{vtkio_vtkavsucdreader}{vtk\-A\-V\-Sucd\-Reader}  
\item \hyperlink{vtkio_vtkbase64inputstream}{vtk\-Base64\-Input\-Stream}  
\item \hyperlink{vtkio_vtkbase64outputstream}{vtk\-Base64\-Output\-Stream}  
\item \hyperlink{vtkio_vtkbase64utilities}{vtk\-Base64\-Utilities}  
\item \hyperlink{vtkio_vtkbmpreader}{vtk\-B\-M\-P\-Reader}  
\item \hyperlink{vtkio_vtkbmpwriter}{vtk\-B\-M\-P\-Writer}  
\item \hyperlink{vtkio_vtkbyureader}{vtk\-B\-Y\-U\-Reader}  
\item \hyperlink{vtkio_vtkbyuwriter}{vtk\-B\-Y\-U\-Writer}  
\item \hyperlink{vtkio_vtkcgmwriter}{vtk\-C\-G\-M\-Writer}  
\item \hyperlink{vtkio_vtkchacoreader}{vtk\-Chaco\-Reader}  
\item \hyperlink{vtkio_vtkdatacompressor}{vtk\-Data\-Compressor}  
\item \hyperlink{vtkio_vtkdataobjectreader}{vtk\-Data\-Object\-Reader}  
\item \hyperlink{vtkio_vtkdataobjectwriter}{vtk\-Data\-Object\-Writer}  
\item \hyperlink{vtkio_vtkdatareader}{vtk\-Data\-Reader}  
\item \hyperlink{vtkio_vtkdatasetreader}{vtk\-Data\-Set\-Reader}  
\item \hyperlink{vtkio_vtkdatasetwriter}{vtk\-Data\-Set\-Writer}  
\item \hyperlink{vtkio_vtkdatawriter}{vtk\-Data\-Writer}  
\item \hyperlink{vtkio_vtkdemreader}{vtk\-D\-E\-M\-Reader}  
\item \hyperlink{vtkio_vtkdicomimagereader}{vtk\-D\-I\-C\-O\-M\-Image\-Reader}  
\item \hyperlink{vtkio_vtkensight6binaryreader}{vtk\-En\-Sight6\-Binary\-Reader}  
\item \hyperlink{vtkio_vtkensight6reader}{vtk\-En\-Sight6\-Reader}  
\item \hyperlink{vtkio_vtkensightgoldbinaryreader}{vtk\-En\-Sight\-Gold\-Binary\-Reader}  
\item \hyperlink{vtkio_vtkensightgoldreader}{vtk\-En\-Sight\-Gold\-Reader}  
\item \hyperlink{vtkio_vtkfacetwriter}{vtk\-Facet\-Writer}  
\item \hyperlink{vtkio_vtkfluentreader}{vtk\-F\-L\-U\-E\-N\-T\-Reader}  
\item \hyperlink{vtkio_vtkgambitreader}{vtk\-G\-A\-M\-B\-I\-T\-Reader}  
\item \hyperlink{vtkio_vtkgaussiancubereader}{vtk\-Gaussian\-Cube\-Reader}  
\item \hyperlink{vtkio_vtkgenericdataobjectreader}{vtk\-Generic\-Data\-Object\-Reader}  
\item \hyperlink{vtkio_vtkgenericdataobjectwriter}{vtk\-Generic\-Data\-Object\-Writer}  
\item \hyperlink{vtkio_vtkgenericensightreader}{vtk\-Generic\-En\-Sight\-Reader}  
\item \hyperlink{vtkio_vtkgenericmoviewriter}{vtk\-Generic\-Movie\-Writer}  
\item \hyperlink{vtkio_vtkgesignareader}{vtk\-G\-E\-Signa\-Reader}  
\item \hyperlink{vtkio_vtkglobfilenames}{vtk\-Glob\-File\-Names}  
\item \hyperlink{vtkio_vtkgraphreader}{vtk\-Graph\-Reader}  
\item \hyperlink{vtkio_vtkgraphwriter}{vtk\-Graph\-Writer}  
\item \hyperlink{vtkio_vtkimagereader}{vtk\-Image\-Reader}  
\item \hyperlink{vtkio_vtkimagereader2}{vtk\-Image\-Reader2}  
\item \hyperlink{vtkio_vtkimagereader2collection}{vtk\-Image\-Reader2\-Collection}  
\item \hyperlink{vtkio_vtkimagereader2factory}{vtk\-Image\-Reader2\-Factory}  
\item \hyperlink{vtkio_vtkimagewriter}{vtk\-Image\-Writer}  
\item \hyperlink{vtkio_vtkinputstream}{vtk\-Input\-Stream}  
\item \hyperlink{vtkio_vtkivwriter}{vtk\-I\-V\-Writer}  
\item \hyperlink{vtkio_vtkjpegreader}{vtk\-J\-P\-E\-G\-Reader}  
\item \hyperlink{vtkio_vtkjpegwriter}{vtk\-J\-P\-E\-G\-Writer}  
\item \hyperlink{vtkio_vtkmateriallibrary}{vtk\-Material\-Library}  
\item \hyperlink{vtkio_vtkmcubesreader}{vtk\-M\-Cubes\-Reader}  
\item \hyperlink{vtkio_vtkmcubeswriter}{vtk\-M\-Cubes\-Writer}  
\item \hyperlink{vtkio_vtkmedicalimageproperties}{vtk\-Medical\-Image\-Properties}  
\item \hyperlink{vtkio_vtkmedicalimagereader2}{vtk\-Medical\-Image\-Reader2}  
\item \hyperlink{vtkio_vtkmetaimagereader}{vtk\-Meta\-Image\-Reader}  
\item \hyperlink{vtkio_vtkmetaimagewriter}{vtk\-Meta\-Image\-Writer}  
\item \hyperlink{vtkio_vtkmfixreader}{vtk\-M\-F\-I\-X\-Reader}  
\item \hyperlink{vtkio_vtkmincimageattributes}{vtk\-M\-I\-N\-C\-Image\-Attributes}  
\item \hyperlink{vtkio_vtkmincimagereader}{vtk\-M\-I\-N\-C\-Image\-Reader}  
\item \hyperlink{vtkio_vtkmincimagewriter}{vtk\-M\-I\-N\-C\-Image\-Writer}  
\item \hyperlink{vtkio_vtkmoleculereaderbase}{vtk\-Molecule\-Reader\-Base}  
\item \hyperlink{vtkio_vtkmultiblockplot3dreader}{vtk\-Multi\-Block\-P\-L\-O\-T3\-D\-Reader}  
\item \hyperlink{vtkio_vtknetcdfcfreader}{vtk\-Net\-C\-D\-F\-C\-F\-Reader}  
\item \hyperlink{vtkio_vtknetcdfpopreader}{vtk\-Net\-C\-D\-F\-P\-O\-P\-Reader}  
\item \hyperlink{vtkio_vtknetcdfreader}{vtk\-Net\-C\-D\-F\-Reader}  
\item \hyperlink{vtkio_vtkobjreader}{vtk\-O\-B\-J\-Reader}  
\item \hyperlink{vtkio_vtkopenfoamreader}{vtk\-Open\-F\-O\-A\-M\-Reader}  
\item \hyperlink{vtkio_vtkoutputstream}{vtk\-Output\-Stream}  
\item \hyperlink{vtkio_vtkparticlereader}{vtk\-Particle\-Reader}  
\item \hyperlink{vtkio_vtkpdbreader}{vtk\-P\-D\-B\-Reader}  
\item \hyperlink{vtkio_vtkplot3dreader}{vtk\-P\-L\-O\-T3\-D\-Reader}  
\item \hyperlink{vtkio_vtkplyreader}{vtk\-P\-L\-Y\-Reader}  
\item \hyperlink{vtkio_vtkplywriter}{vtk\-P\-L\-Y\-Writer}  
\item \hyperlink{vtkio_vtkpngreader}{vtk\-P\-N\-G\-Reader}  
\item \hyperlink{vtkio_vtkpngwriter}{vtk\-P\-N\-G\-Writer}  
\item \hyperlink{vtkio_vtkpnmreader}{vtk\-P\-N\-M\-Reader}  
\item \hyperlink{vtkio_vtkpnmwriter}{vtk\-P\-N\-M\-Writer}  
\item \hyperlink{vtkio_vtkpolydatareader}{vtk\-Poly\-Data\-Reader}  
\item \hyperlink{vtkio_vtkpolydatawriter}{vtk\-Poly\-Data\-Writer}  
\item \hyperlink{vtkio_vtkpostscriptwriter}{vtk\-Post\-Script\-Writer}  
\item \hyperlink{vtkio_vtkrectilineargridreader}{vtk\-Rectilinear\-Grid\-Reader}  
\item \hyperlink{vtkio_vtkrectilineargridwriter}{vtk\-Rectilinear\-Grid\-Writer}  
\item \hyperlink{vtkio_vtkrowquery}{vtk\-Row\-Query}  
\item \hyperlink{vtkio_vtkrowquerytotable}{vtk\-Row\-Query\-To\-Table}  
\item \hyperlink{vtkio_vtkrtxmlpolydatareader}{vtk\-R\-T\-X\-M\-L\-Poly\-Data\-Reader}  
\item \hyperlink{vtkio_vtksesamereader}{vtk\-S\-E\-S\-A\-M\-E\-Reader}  
\item \hyperlink{vtkio_vtkshadercodelibrary}{vtk\-Shader\-Code\-Library}  
\item \hyperlink{vtkio_vtksimplepointsreader}{vtk\-Simple\-Points\-Reader}  
\item \hyperlink{vtkio_vtkslacparticlereader}{vtk\-S\-L\-A\-C\-Particle\-Reader}  
\item \hyperlink{vtkio_vtkslacreader}{vtk\-S\-L\-A\-C\-Reader}  
\item \hyperlink{vtkio_vtkslcreader}{vtk\-S\-L\-C\-Reader}  
\item \hyperlink{vtkio_vtksortfilenames}{vtk\-Sort\-File\-Names}  
\item \hyperlink{vtkio_vtksqldatabase}{vtk\-S\-Q\-L\-Database}  
\item \hyperlink{vtkio_vtksqldatabaseschema}{vtk\-S\-Q\-L\-Database\-Schema}  
\item \hyperlink{vtkio_vtksqlitedatabase}{vtk\-S\-Q\-Lite\-Database}  
\item \hyperlink{vtkio_vtksqlitequery}{vtk\-S\-Q\-Lite\-Query}  
\item \hyperlink{vtkio_vtksqlquery}{vtk\-S\-Q\-L\-Query}  
\item \hyperlink{vtkio_vtkstlreader}{vtk\-S\-T\-L\-Reader}  
\item \hyperlink{vtkio_vtkstlwriter}{vtk\-S\-T\-L\-Writer}  
\item \hyperlink{vtkio_vtkstructuredgridreader}{vtk\-Structured\-Grid\-Reader}  
\item \hyperlink{vtkio_vtkstructuredgridwriter}{vtk\-Structured\-Grid\-Writer}  
\item \hyperlink{vtkio_vtkstructuredpointsreader}{vtk\-Structured\-Points\-Reader}  
\item \hyperlink{vtkio_vtkstructuredpointswriter}{vtk\-Structured\-Points\-Writer}  
\item \hyperlink{vtkio_vtktablereader}{vtk\-Table\-Reader}  
\item \hyperlink{vtkio_vtktablewriter}{vtk\-Table\-Writer}  
\item \hyperlink{vtkio_vtktecplotreader}{vtk\-Tecplot\-Reader}  
\item \hyperlink{vtkio_vtktiffreader}{vtk\-T\-I\-F\-F\-Reader}  
\item \hyperlink{vtkio_vtktiffwriter}{vtk\-T\-I\-F\-F\-Writer}  
\item \hyperlink{vtkio_vtktreereader}{vtk\-Tree\-Reader}  
\item \hyperlink{vtkio_vtktreewriter}{vtk\-Tree\-Writer}  
\item \hyperlink{vtkio_vtkugfacetreader}{vtk\-U\-G\-Facet\-Reader}  
\item \hyperlink{vtkio_vtkunstructuredgridreader}{vtk\-Unstructured\-Grid\-Reader}  
\item \hyperlink{vtkio_vtkunstructuredgridwriter}{vtk\-Unstructured\-Grid\-Writer}  
\item \hyperlink{vtkio_vtkvolume16reader}{vtk\-Volume16\-Reader}  
\item \hyperlink{vtkio_vtkvolumereader}{vtk\-Volume\-Reader}  
\item \hyperlink{vtkio_vtkwriter}{vtk\-Writer}  
\item \hyperlink{vtkio_vtkxmlcompositedatareader}{vtk\-X\-M\-L\-Composite\-Data\-Reader}  
\item \hyperlink{vtkio_vtkxmlcompositedatawriter}{vtk\-X\-M\-L\-Composite\-Data\-Writer}  
\item \hyperlink{vtkio_vtkxmldataparser}{vtk\-X\-M\-L\-Data\-Parser}  
\item \hyperlink{vtkio_vtkxmldatareader}{vtk\-X\-M\-L\-Data\-Reader}  
\item \hyperlink{vtkio_vtkxmldatasetwriter}{vtk\-X\-M\-L\-Data\-Set\-Writer}  
\item \hyperlink{vtkio_vtkxmlfilereadtester}{vtk\-X\-M\-L\-File\-Read\-Tester}  
\item \hyperlink{vtkio_vtkxmlhierarchicalboxdatareader}{vtk\-X\-M\-L\-Hierarchical\-Box\-Data\-Reader}  
\item \hyperlink{vtkio_vtkxmlhierarchicalboxdatawriter}{vtk\-X\-M\-L\-Hierarchical\-Box\-Data\-Writer}  
\item \hyperlink{vtkio_vtkxmlhierarchicaldatareader}{vtk\-X\-M\-L\-Hierarchical\-Data\-Reader}  
\item \hyperlink{vtkio_vtkxmlhyperoctreereader}{vtk\-X\-M\-L\-Hyper\-Octree\-Reader}  
\item \hyperlink{vtkio_vtkxmlhyperoctreewriter}{vtk\-X\-M\-L\-Hyper\-Octree\-Writer}  
\item \hyperlink{vtkio_vtkxmlimagedatareader}{vtk\-X\-M\-L\-Image\-Data\-Reader}  
\item \hyperlink{vtkio_vtkxmlimagedatawriter}{vtk\-X\-M\-L\-Image\-Data\-Writer}  
\item \hyperlink{vtkio_vtkxmlmaterial}{vtk\-X\-M\-L\-Material}  
\item \hyperlink{vtkio_vtkxmlmaterialparser}{vtk\-X\-M\-L\-Material\-Parser}  
\item \hyperlink{vtkio_vtkxmlmaterialreader}{vtk\-X\-M\-L\-Material\-Reader}  
\item \hyperlink{vtkio_vtkxmlmultiblockdatareader}{vtk\-X\-M\-L\-Multi\-Block\-Data\-Reader}  
\item \hyperlink{vtkio_vtkxmlmultiblockdatawriter}{vtk\-X\-M\-L\-Multi\-Block\-Data\-Writer}  
\item \hyperlink{vtkio_vtkxmlmultigroupdatareader}{vtk\-X\-M\-L\-Multi\-Group\-Data\-Reader}  
\item \hyperlink{vtkio_vtkxmlparser}{vtk\-X\-M\-L\-Parser}  
\item \hyperlink{vtkio_vtkxmlpdatareader}{vtk\-X\-M\-L\-P\-Data\-Reader}  
\item \hyperlink{vtkio_vtkxmlpdatasetwriter}{vtk\-X\-M\-L\-P\-Data\-Set\-Writer}  
\item \hyperlink{vtkio_vtkxmlpdatawriter}{vtk\-X\-M\-L\-P\-Data\-Writer}  
\item \hyperlink{vtkio_vtkxmlpimagedatareader}{vtk\-X\-M\-L\-P\-Image\-Data\-Reader}  
\item \hyperlink{vtkio_vtkxmlpimagedatawriter}{vtk\-X\-M\-L\-P\-Image\-Data\-Writer}  
\item \hyperlink{vtkio_vtkxmlpolydatareader}{vtk\-X\-M\-L\-Poly\-Data\-Reader}  
\item \hyperlink{vtkio_vtkxmlpolydatawriter}{vtk\-X\-M\-L\-Poly\-Data\-Writer}  
\item \hyperlink{vtkio_vtkxmlppolydatareader}{vtk\-X\-M\-L\-P\-Poly\-Data\-Reader}  
\item \hyperlink{vtkio_vtkxmlppolydatawriter}{vtk\-X\-M\-L\-P\-Poly\-Data\-Writer}  
\item \hyperlink{vtkio_vtkxmlprectilineargridreader}{vtk\-X\-M\-L\-P\-Rectilinear\-Grid\-Reader}  
\item \hyperlink{vtkio_vtkxmlprectilineargridwriter}{vtk\-X\-M\-L\-P\-Rectilinear\-Grid\-Writer}  
\item \hyperlink{vtkio_vtkxmlpstructureddatareader}{vtk\-X\-M\-L\-P\-Structured\-Data\-Reader}  
\item \hyperlink{vtkio_vtkxmlpstructureddatawriter}{vtk\-X\-M\-L\-P\-Structured\-Data\-Writer}  
\item \hyperlink{vtkio_vtkxmlpstructuredgridreader}{vtk\-X\-M\-L\-P\-Structured\-Grid\-Reader}  
\item \hyperlink{vtkio_vtkxmlpstructuredgridwriter}{vtk\-X\-M\-L\-P\-Structured\-Grid\-Writer}  
\item \hyperlink{vtkio_vtkxmlpunstructureddatareader}{vtk\-X\-M\-L\-P\-Unstructured\-Data\-Reader}  
\item \hyperlink{vtkio_vtkxmlpunstructureddatawriter}{vtk\-X\-M\-L\-P\-Unstructured\-Data\-Writer}  
\item \hyperlink{vtkio_vtkxmlpunstructuredgridreader}{vtk\-X\-M\-L\-P\-Unstructured\-Grid\-Reader}  
\item \hyperlink{vtkio_vtkxmlpunstructuredgridwriter}{vtk\-X\-M\-L\-P\-Unstructured\-Grid\-Writer}  
\item \hyperlink{vtkio_vtkxmlreader}{vtk\-X\-M\-L\-Reader}  
\item \hyperlink{vtkio_vtkxmlrectilineargridreader}{vtk\-X\-M\-L\-Rectilinear\-Grid\-Reader}  
\item \hyperlink{vtkio_vtkxmlrectilineargridwriter}{vtk\-X\-M\-L\-Rectilinear\-Grid\-Writer}  
\item \hyperlink{vtkio_vtkxmlshader}{vtk\-X\-M\-L\-Shader}  
\item \hyperlink{vtkio_vtkxmlstructureddatareader}{vtk\-X\-M\-L\-Structured\-Data\-Reader}  
\item \hyperlink{vtkio_vtkxmlstructureddatawriter}{vtk\-X\-M\-L\-Structured\-Data\-Writer}  
\item \hyperlink{vtkio_vtkxmlstructuredgridreader}{vtk\-X\-M\-L\-Structured\-Grid\-Reader}  
\item \hyperlink{vtkio_vtkxmlstructuredgridwriter}{vtk\-X\-M\-L\-Structured\-Grid\-Writer}  
\item \hyperlink{vtkio_vtkxmlunstructureddatareader}{vtk\-X\-M\-L\-Unstructured\-Data\-Reader}  
\item \hyperlink{vtkio_vtkxmlunstructureddatawriter}{vtk\-X\-M\-L\-Unstructured\-Data\-Writer}  
\item \hyperlink{vtkio_vtkxmlunstructuredgridreader}{vtk\-X\-M\-L\-Unstructured\-Grid\-Reader}  
\item \hyperlink{vtkio_vtkxmlunstructuredgridwriter}{vtk\-X\-M\-L\-Unstructured\-Grid\-Writer}  
\item \hyperlink{vtkio_vtkxmlutilities}{vtk\-X\-M\-L\-Utilities}  
\item \hyperlink{vtkio_vtkxmlwriter}{vtk\-X\-M\-L\-Writer}  
\item \hyperlink{vtkio_vtkxyzmolreader}{vtk\-X\-Y\-Z\-Mol\-Reader}  
\item \hyperlink{vtkio_vtkzlibdatacompressor}{vtk\-Z\-Lib\-Data\-Compressor}  
\end{DoxyItemize}\hypertarget{vtkio_vtkabstractparticlewriter}{}\section{vtk\-Abstract\-Particle\-Writer}\label{vtkio_vtkabstractparticlewriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Abstract\-Particle\-Writer is an abstract class which is used by vtk\-Temporal\-Stream\-Tracer to write particles out during simulations. This class is abstract and provides a Time\-Step and File\-Name. Subclasses of this should provide the necessary I\-O.

To create an instance of class vtk\-Abstract\-Particle\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAbstractParticleWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Abstract\-Particle\-Writer 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\-Particle\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Abstract\-Particle\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Abstract\-Particle\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Time\-Step (int )} -\/ Set/get the Time\-Step that is being written  
\item {\ttfamily int = obj.\-Get\-Time\-Step ()} -\/ Set/get the Time\-Step that is being written  
\item {\ttfamily obj.\-Set\-Time\-Value (double )} -\/ Before writing the current data out, set the Time\-Value (optional) The Time\-Value is a float/double value that corresonds to the real time of the data, it may not be regular, whereas the Time\-Steps are simple increments.  
\item {\ttfamily double = obj.\-Get\-Time\-Value ()} -\/ Before writing the current data out, set the Time\-Value (optional) The Time\-Value is a float/double value that corresonds to the real time of the data, it may not be regular, whereas the Time\-Steps are simple increments.  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Set/get the File\-Name that is being written to  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Set/get the File\-Name that is being written to  
\item {\ttfamily obj.\-Set\-Collective\-I\-O (int )} -\/ When running in parallel, this writer may be capable of Collective I\-O operations (H\-D\-F5). By default, this is off.  
\item {\ttfamily int = obj.\-Get\-Collective\-I\-O ()} -\/ When running in parallel, this writer may be capable of Collective I\-O operations (H\-D\-F5). By default, this is off.  
\item {\ttfamily obj.\-Set\-Write\-Mode\-To\-Collective ()} -\/ When running in parallel, this writer may be capable of Collective I\-O operations (H\-D\-F5). By default, this is off.  
\item {\ttfamily obj.\-Set\-Write\-Mode\-To\-Independent ()} -\/ When running in parallel, this writer may be capable of Collective I\-O operations (H\-D\-F5). By default, this is off.  
\item {\ttfamily obj.\-Close\-File ()} -\/ Close the file after a write. This is optional but may protect against data loss in between steps  
\end{DoxyItemize}\hypertarget{vtkio_vtkarrayreader}{}\section{vtk\-Array\-Reader}\label{vtkio_vtkarrayreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Reads sparse and dense vtk\-Array data written with vtk\-Array\-Writer.

Outputs\-: Output port 0\-: vtk\-Array\-Data containing a dense or sparse array.

To create an instance of class vtk\-Array\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkArrayReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Array\-Reader 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\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Array\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Array\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Set the filesystem location from which data will be read.  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Set the filesystem location from which data will be read.  
\end{DoxyItemize}\hypertarget{vtkio_vtkarraywriter}{}\section{vtk\-Array\-Writer}\label{vtkio_vtkarraywriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Array\-Writer serializes sparse and dense array data using a text-\/based format that is human-\/readable and easily parsed (default option). The Write\-Binary array option can be set to true in the Write method, which will serialize the sparse and dense array data using a binary format that is optimized for rapid throughput.

Inputs\-: Input port 0\-: (required) vtk\-Array\-Data object containing a sparse or dense array.

Output Format\-: The first line of output will contain the array type (sparse or dense) and the type of values stored in the array (double, integer, string, etc).

The second line of output will contain the array extents along each dimension of the array, followed by the number of non-\/null values stored in the array.

For sparse arrays, each subsequent line of output will contain the coordinates and value for each non-\/null value stored in the array.

For dense arrays, each subsequent line of output will contain one value from the array, stored in the same order as that used by vtk\-Array\-Coordinate\-Iterator.

To create an instance of class vtk\-Array\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkArrayWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Array\-Writer 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\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Array\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Array\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily bool = obj.\-Write (vtk\-Std\-String \&file\-\_\-name, bool Write\-Binaryfalse)} -\/ Write input port 0 data to a file.  
\end{DoxyItemize}\hypertarget{vtkio_vtkavsucdreader}{}\section{vtk\-A\-V\-Sucd\-Reader}\label{vtkio_vtkavsucdreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-A\-V\-Sucd\-Reader creates an unstructured grid dataset. It reads binary or A\-S\-C\-I\-I files stored in U\-C\-D format, with optional data stored at the nodes or at the cells of the model. A cell-\/based fielddata stores the material id. The class can automatically detect the endian-\/ness of the binary files.

To create an instance of class vtk\-A\-V\-Sucd\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAVSucdReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-A\-V\-Sucd\-Reader 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\-A\-V\-Sucd\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-A\-V\-Sucd\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-A\-V\-Sucd\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify file name of A\-V\-S U\-C\-D datafile to read  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify file name of A\-V\-S U\-C\-D datafile to read  
\item {\ttfamily obj.\-Set\-Binary\-File (int )} -\/ Is the file to be read written in binary format (as opposed to ascii).  
\item {\ttfamily int = obj.\-Get\-Binary\-File ()} -\/ Is the file to be read written in binary format (as opposed to ascii).  
\item {\ttfamily obj.\-Binary\-File\-On ()} -\/ Is the file to be read written in binary format (as opposed to ascii).  
\item {\ttfamily obj.\-Binary\-File\-Off ()} -\/ Is the file to be read written in binary format (as opposed to ascii).  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Cells ()} -\/ Get the total number of cells.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Nodes ()} -\/ Get the total number of nodes.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Node\-Fields ()} -\/ Get the number of data fields at the nodes.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Cell\-Fields ()} -\/ Get the number of data fields at the cell centers.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Fields ()} -\/ Get the number of data fields for the model. Unused because V\-T\-K has no methods for it.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Node\-Components ()} -\/ Get the number of data components at the nodes and cells.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Cell\-Components ()} -\/ Get the number of data components at the nodes and cells.  
\item {\ttfamily obj.\-Set\-Byte\-Order\-To\-Big\-Endian ()} -\/ Set/\-Get the endian-\/ness of the binary file.  
\item {\ttfamily obj.\-Set\-Byte\-Order\-To\-Little\-Endian ()} -\/ Set/\-Get the endian-\/ness of the binary file.  
\item {\ttfamily string = obj.\-Get\-Byte\-Order\-As\-String ()} -\/ Set/\-Get the endian-\/ness of the binary file.  
\item {\ttfamily obj.\-Set\-Byte\-Order (int )}  
\item {\ttfamily int = obj.\-Get\-Byte\-Order ()}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Point\-Arrays ()} -\/ The following methods allow selective reading of solutions fields. by default, A\-L\-L data fields are the nodes and cells are read, but this can be modified.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Cell\-Arrays ()} -\/ The following methods allow selective reading of solutions fields. by default, A\-L\-L data fields are the nodes and cells are read, but this can be modified.  
\item {\ttfamily string = obj.\-Get\-Point\-Array\-Name (int index)} -\/ The following methods allow selective reading of solutions fields. by default, A\-L\-L data fields are the nodes and cells are read, but this can be modified.  
\item {\ttfamily string = obj.\-Get\-Cell\-Array\-Name (int index)} -\/ The following methods allow selective reading of solutions fields. by default, A\-L\-L data fields are the nodes and cells are read, but this can be modified.  
\item {\ttfamily int = obj.\-Get\-Point\-Array\-Status (string name)} -\/ The following methods allow selective reading of solutions fields. by default, A\-L\-L data fields are the nodes and cells are read, but this can be modified.  
\item {\ttfamily int = obj.\-Get\-Cell\-Array\-Status (string name)} -\/ The following methods allow selective reading of solutions fields. by default, A\-L\-L data fields are the nodes and cells are read, but this can be modified.  
\item {\ttfamily obj.\-Set\-Point\-Array\-Status (string name, int status)} -\/ The following methods allow selective reading of solutions fields. by default, A\-L\-L data fields are the nodes and cells are read, but this can be modified.  
\item {\ttfamily obj.\-Set\-Cell\-Array\-Status (string name, int status)} -\/ The following methods allow selective reading of solutions fields. by default, A\-L\-L data fields are the nodes and cells are read, but this can be modified.  
\item {\ttfamily obj.\-Disable\-All\-Cell\-Arrays ()}  
\item {\ttfamily obj.\-Enable\-All\-Cell\-Arrays ()}  
\item {\ttfamily obj.\-Disable\-All\-Point\-Arrays ()}  
\item {\ttfamily obj.\-Enable\-All\-Point\-Arrays ()}  
\item {\ttfamily obj.\-Get\-Cell\-Data\-Range (int cell\-Comp, int index, float min, float max)}  
\item {\ttfamily obj.\-Get\-Node\-Data\-Range (int node\-Comp, int index, float min, float max)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkbase64inputstream}{}\section{vtk\-Base64\-Input\-Stream}\label{vtkio_vtkbase64inputstream}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Base64\-Input\-Stream implements base64 decoding with the vtk\-Input\-Stream interface.

To create an instance of class vtk\-Base64\-Input\-Stream, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBase64InputStream
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Base64\-Input\-Stream 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\-Base64\-Input\-Stream class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Base64\-Input\-Stream = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Base64\-Input\-Stream = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Start\-Reading ()} -\/ Called after the stream position has been set by the caller, but before any Seek or Read calls. The stream position should not be adjusted by the caller until after an End\-Reading call.  
\item {\ttfamily int = obj.\-Seek (long offset)} -\/ Seek to the given offset in the input data. Returns 1 for success, 0 for failure.  
\item {\ttfamily long = obj.\-Read (string data, long length)} -\/ Read input data of the given length. Returns amount actually read.  
\item {\ttfamily obj.\-End\-Reading ()} -\/ Called after all desired calls to Seek and Read have been made. After this call, the caller is free to change the position of the stream. Additional reads should not be done until after another call to Start\-Reading.  
\end{DoxyItemize}\hypertarget{vtkio_vtkbase64outputstream}{}\section{vtk\-Base64\-Output\-Stream}\label{vtkio_vtkbase64outputstream}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Base64\-Output\-Stream implements base64 encoding with the vtk\-Output\-Stream interface.

To create an instance of class vtk\-Base64\-Output\-Stream, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBase64OutputStream
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Base64\-Output\-Stream 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\-Base64\-Output\-Stream class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Base64\-Output\-Stream = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Base64\-Output\-Stream = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Start\-Writing ()} -\/ Called after the stream position has been set by the caller, but before any Write calls. The stream position should not be adjusted by the caller until after an End\-Writing call.  
\item {\ttfamily int = obj.\-Write (string data, long length)} -\/ Write output data of the given length.  
\item {\ttfamily int = obj.\-End\-Writing ()} -\/ Called after all desired calls to Write have been made. After this call, the caller is free to change the position of the stream. Additional writes should not be done until after another call to Start\-Writing.  
\end{DoxyItemize}\hypertarget{vtkio_vtkbase64utilities}{}\section{vtk\-Base64\-Utilities}\label{vtkio_vtkbase64utilities}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Base64\-Utilities implements base64 encoding and decoding.

To create an instance of class vtk\-Base64\-Utilities, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBase64Utilities
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Base64\-Utilities 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\-Base64\-Utilities class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Base64\-Utilities = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Base64\-Utilities = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkbmpreader}{}\section{vtk\-B\-M\-P\-Reader}\label{vtkio_vtkbmpreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-B\-M\-P\-Reader is a source object that reads Windows B\-M\-P files. This includes indexed and 24bit bitmaps Usually, all B\-M\-Ps are converted to 24bit R\-G\-B, but B\-M\-Ps may be output as 8bit images with a Lookup\-Table if the Allow8\-Bit\-B\-M\-P flag is set.

B\-M\-P\-Reader creates structured point datasets. The dimension of the dataset depends upon the number of files read. Reading a single file results in a 2\-D image, while reading more than one file results in a 3\-D volume.

To read a volume, files must be of the form \char`\"{}\-File\-Name.$<$number$>$\char`\"{} (e.\-g., foo.\-bmp.\-0, foo.\-bmp.\-1, ...). You must also specify the image range. This range specifies the beginning and ending files to read (range can be any pair of non-\/negative numbers).

The default behavior is to read a single file. In this case, the form of the file is simply \char`\"{}\-File\-Name\char`\"{} (e.\-g., foo.\-bmp).

To create an instance of class vtk\-B\-M\-P\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBMPReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-B\-M\-P\-Reader 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\-B\-M\-P\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-B\-M\-P\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-B\-M\-P\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Depth ()} -\/ Returns the depth of the B\-M\-P, either 8 or 24.  
\item {\ttfamily int = obj.\-Can\-Read\-File (string fname)} -\/ Is the given file a B\-M\-P file?  
\item {\ttfamily string = obj.\-Get\-File\-Extensions ()} -\/ Return a descriptive name for the file format that might be useful in a G\-U\-I.  
\item {\ttfamily string = obj.\-Get\-Descriptive\-Name ()} -\/ If this flag is set and the B\-M\-P reader encounters an 8bit file, the data will be kept as unsigned chars and a lookuptable will be exported  
\item {\ttfamily obj.\-Set\-Allow8\-Bit\-B\-M\-P (int )} -\/ If this flag is set and the B\-M\-P reader encounters an 8bit file, the data will be kept as unsigned chars and a lookuptable will be exported  
\item {\ttfamily int = obj.\-Get\-Allow8\-Bit\-B\-M\-P ()} -\/ If this flag is set and the B\-M\-P reader encounters an 8bit file, the data will be kept as unsigned chars and a lookuptable will be exported  
\item {\ttfamily obj.\-Allow8\-Bit\-B\-M\-P\-On ()} -\/ If this flag is set and the B\-M\-P reader encounters an 8bit file, the data will be kept as unsigned chars and a lookuptable will be exported  
\item {\ttfamily obj.\-Allow8\-Bit\-B\-M\-P\-Off ()} -\/ If this flag is set and the B\-M\-P reader encounters an 8bit file, the data will be kept as unsigned chars and a lookuptable will be exported  
\item {\ttfamily vtk\-Lookup\-Table = obj.\-Get\-Lookup\-Table ()}  
\end{DoxyItemize}\hypertarget{vtkio_vtkbmpwriter}{}\section{vtk\-B\-M\-P\-Writer}\label{vtkio_vtkbmpwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-B\-M\-P\-Writer writes B\-M\-P files. The data type of the file is unsigned char regardless of the input type.

To create an instance of class vtk\-B\-M\-P\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBMPWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-B\-M\-P\-Writer 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\-B\-M\-P\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-B\-M\-P\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-B\-M\-P\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkbyureader}{}\section{vtk\-B\-Y\-U\-Reader}\label{vtkio_vtkbyureader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-B\-Y\-U\-Reader is a source object that reads M\-O\-V\-I\-E.\-B\-Y\-U polygon files. These files consist of a geometry file (.g), a scalar file (.s), a displacement or vector file (.d), and a 2\-D texture coordinate file (.t).

To create an instance of class vtk\-B\-Y\-U\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBYUReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-B\-Y\-U\-Reader 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\-B\-Y\-U\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-B\-Y\-U\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-B\-Y\-U\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Geometry\-File\-Name (string )} -\/ Specify name of geometry File\-Name.  
\item {\ttfamily string = obj.\-Get\-Geometry\-File\-Name ()} -\/ Specify name of geometry File\-Name.  
\item {\ttfamily obj.\-Set\-File\-Name (string f)} -\/ Specify name of geometry File\-Name (alias).  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify name of displacement File\-Name.  
\item {\ttfamily obj.\-Set\-Displacement\-File\-Name (string )} -\/ Specify name of displacement File\-Name.  
\item {\ttfamily string = obj.\-Get\-Displacement\-File\-Name ()} -\/ Specify name of displacement File\-Name.  
\item {\ttfamily obj.\-Set\-Scalar\-File\-Name (string )} -\/ Specify name of scalar File\-Name.  
\item {\ttfamily string = obj.\-Get\-Scalar\-File\-Name ()} -\/ Specify name of scalar File\-Name.  
\item {\ttfamily obj.\-Set\-Texture\-File\-Name (string )} -\/ Specify name of texture coordinates File\-Name.  
\item {\ttfamily string = obj.\-Get\-Texture\-File\-Name ()} -\/ Specify name of texture coordinates File\-Name.  
\item {\ttfamily obj.\-Set\-Read\-Displacement (int )} -\/ Turn on/off the reading of the displacement file.  
\item {\ttfamily int = obj.\-Get\-Read\-Displacement ()} -\/ Turn on/off the reading of the displacement file.  
\item {\ttfamily obj.\-Read\-Displacement\-On ()} -\/ Turn on/off the reading of the displacement file.  
\item {\ttfamily obj.\-Read\-Displacement\-Off ()} -\/ Turn on/off the reading of the displacement file.  
\item {\ttfamily obj.\-Set\-Read\-Scalar (int )} -\/ Turn on/off the reading of the scalar file.  
\item {\ttfamily int = obj.\-Get\-Read\-Scalar ()} -\/ Turn on/off the reading of the scalar file.  
\item {\ttfamily obj.\-Read\-Scalar\-On ()} -\/ Turn on/off the reading of the scalar file.  
\item {\ttfamily obj.\-Read\-Scalar\-Off ()} -\/ Turn on/off the reading of the scalar file.  
\item {\ttfamily obj.\-Set\-Read\-Texture (int )} -\/ Turn on/off the reading of the texture coordinate file. Specify name of geometry File\-Name.  
\item {\ttfamily int = obj.\-Get\-Read\-Texture ()} -\/ Turn on/off the reading of the texture coordinate file. Specify name of geometry File\-Name.  
\item {\ttfamily obj.\-Read\-Texture\-On ()} -\/ Turn on/off the reading of the texture coordinate file. Specify name of geometry File\-Name.  
\item {\ttfamily obj.\-Read\-Texture\-Off ()} -\/ Turn on/off the reading of the texture coordinate file. Specify name of geometry File\-Name.  
\item {\ttfamily obj.\-Set\-Part\-Number (int )} -\/ Set/\-Get the part number to be read.  
\item {\ttfamily int = obj.\-Get\-Part\-Number\-Min\-Value ()} -\/ Set/\-Get the part number to be read.  
\item {\ttfamily int = obj.\-Get\-Part\-Number\-Max\-Value ()} -\/ Set/\-Get the part number to be read.  
\item {\ttfamily int = obj.\-Get\-Part\-Number ()} -\/ Set/\-Get the part number to be read.  
\end{DoxyItemize}\hypertarget{vtkio_vtkbyuwriter}{}\section{vtk\-B\-Y\-U\-Writer}\label{vtkio_vtkbyuwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-B\-Y\-U\-Writer writes M\-O\-V\-I\-E.\-B\-Y\-U polygonal files. These files consist of a geometry file (.g), a scalar file (.s), a displacement or vector file (.d), and a 2\-D texture coordinate file (.t). These files must be specified to the object, the appropriate boolean variables must be true, and data must be available from the input for the files to be written. W\-A\-R\-N\-I\-N\-G\-: this writer does not currently write triangle strips. Use vtk\-Triangle\-Filter to convert strips to triangles.

To create an instance of class vtk\-B\-Y\-U\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBYUWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-B\-Y\-U\-Writer 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\-B\-Y\-U\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-B\-Y\-U\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-B\-Y\-U\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Geometry\-File\-Name (string )} -\/ Specify the name of the geometry file to write.  
\item {\ttfamily string = obj.\-Get\-Geometry\-File\-Name ()} -\/ Specify the name of the geometry file to write.  
\item {\ttfamily obj.\-Set\-Displacement\-File\-Name (string )} -\/ Specify the name of the displacement file to write.  
\item {\ttfamily string = obj.\-Get\-Displacement\-File\-Name ()} -\/ Specify the name of the displacement file to write.  
\item {\ttfamily obj.\-Set\-Scalar\-File\-Name (string )} -\/ Specify the name of the scalar file to write.  
\item {\ttfamily string = obj.\-Get\-Scalar\-File\-Name ()} -\/ Specify the name of the scalar file to write.  
\item {\ttfamily obj.\-Set\-Texture\-File\-Name (string )} -\/ Specify the name of the texture file to write.  
\item {\ttfamily string = obj.\-Get\-Texture\-File\-Name ()} -\/ Specify the name of the texture file to write.  
\item {\ttfamily obj.\-Set\-Write\-Displacement (int )} -\/ Turn on/off writing the displacement file.  
\item {\ttfamily int = obj.\-Get\-Write\-Displacement ()} -\/ Turn on/off writing the displacement file.  
\item {\ttfamily obj.\-Write\-Displacement\-On ()} -\/ Turn on/off writing the displacement file.  
\item {\ttfamily obj.\-Write\-Displacement\-Off ()} -\/ Turn on/off writing the displacement file.  
\item {\ttfamily obj.\-Set\-Write\-Scalar (int )} -\/ Turn on/off writing the scalar file.  
\item {\ttfamily int = obj.\-Get\-Write\-Scalar ()} -\/ Turn on/off writing the scalar file.  
\item {\ttfamily obj.\-Write\-Scalar\-On ()} -\/ Turn on/off writing the scalar file.  
\item {\ttfamily obj.\-Write\-Scalar\-Off ()} -\/ Turn on/off writing the scalar file.  
\item {\ttfamily obj.\-Set\-Write\-Texture (int )} -\/ Turn on/off writing the texture file.  
\item {\ttfamily int = obj.\-Get\-Write\-Texture ()} -\/ Turn on/off writing the texture file.  
\item {\ttfamily obj.\-Write\-Texture\-On ()} -\/ Turn on/off writing the texture file.  
\item {\ttfamily obj.\-Write\-Texture\-Off ()} -\/ Turn on/off writing the texture file.  
\end{DoxyItemize}\hypertarget{vtkio_vtkcgmwriter}{}\section{vtk\-C\-G\-M\-Writer}\label{vtkio_vtkcgmwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-C\-G\-M\-Writer writes C\-G\-M (Computer Graphics Metafile) output. C\-G\-M is a 2\-D graphics vector format typically used by large plotters. This writer can handle vertices, lines, polygons, and triangle strips in any combination. Colors are specified either 1) from cell scalars (assumed to be R\-G\-B or R\-G\-B\-A color specification), 2) from a specified color; or 3) randomly assigned colors.

Note\-: During output of the polygonal data, triangle strips are converted to triangles, and polylines to lines. Also, due to limitations in the C\-G\-M color model, only 256 colors are available to the color palette.

To create an instance of class vtk\-C\-G\-M\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCGMWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-C\-G\-M\-Writer 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\-C\-G\-M\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-C\-G\-M\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-C\-G\-M\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Viewport (vtk\-Viewport )} -\/ Specify a vtk\-Viewport object to be used to transform the vtk\-Poly\-Data points into 2\-D coordinates. By default (no vtk\-Viewport specified), the point coordinates are generated by ignoring the z values. If a viewport is defined, then the points are transformed into viewport coordinates.  
\item {\ttfamily vtk\-Viewport = obj.\-Get\-Viewport ()} -\/ Specify a vtk\-Viewport object to be used to transform the vtk\-Poly\-Data points into 2\-D coordinates. By default (no vtk\-Viewport specified), the point coordinates are generated by ignoring the z values. If a viewport is defined, then the points are transformed into viewport coordinates.  
\item {\ttfamily obj.\-Set\-Sort (int )} -\/ Turn on/off the sorting of the cells via depth. If enabled, polygonal cells will be sorted from back to front, i.\-e., a Painter's algorithm sort.  
\item {\ttfamily int = obj.\-Get\-Sort ()} -\/ Turn on/off the sorting of the cells via depth. If enabled, polygonal cells will be sorted from back to front, i.\-e., a Painter's algorithm sort.  
\item {\ttfamily obj.\-Set\-Resolution (int )} -\/ Specify the resolution of the C\-G\-M file. This number is used to integerize the maximum coordinate range of the plot file.  
\item {\ttfamily int = obj.\-Get\-Resolution\-Min\-Value ()} -\/ Specify the resolution of the C\-G\-M file. This number is used to integerize the maximum coordinate range of the plot file.  
\item {\ttfamily int = obj.\-Get\-Resolution\-Max\-Value ()} -\/ Specify the resolution of the C\-G\-M file. This number is used to integerize the maximum coordinate range of the plot file.  
\item {\ttfamily int = obj.\-Get\-Resolution ()} -\/ Specify the resolution of the C\-G\-M file. This number is used to integerize the maximum coordinate range of the plot file.  
\item {\ttfamily obj.\-Set\-Color\-Mode (int )} -\/ Control how output polydata is colored. By default (Color\-Mode\-To\-Default), if per cell colors are defined (unsigned chars of 1-\/4 components), then the cells are colored with these values. (If point colors are defined and cell colors are not, you can use vtk\-Point\-Data\-To\-Cell\-Data to convert the point colors to cell colors.) Otherwise, by default, the cells are set to the specified color. If Color\-Mode\-To\-Specified\-Color is set, then the primitives will all be set to this color. If Color\-Mode\-To\-Random\-Colors is set, each cell will be randomly assigned a color.  
\item {\ttfamily int = obj.\-Get\-Color\-Mode ()} -\/ Control how output polydata is colored. By default (Color\-Mode\-To\-Default), if per cell colors are defined (unsigned chars of 1-\/4 components), then the cells are colored with these values. (If point colors are defined and cell colors are not, you can use vtk\-Point\-Data\-To\-Cell\-Data to convert the point colors to cell colors.) Otherwise, by default, the cells are set to the specified color. If Color\-Mode\-To\-Specified\-Color is set, then the primitives will all be set to this color. If Color\-Mode\-To\-Random\-Colors is set, each cell will be randomly assigned a color.  
\item {\ttfamily obj.\-Set\-Color\-Mode\-To\-Default ()} -\/ Control how output polydata is colored. By default (Color\-Mode\-To\-Default), if per cell colors are defined (unsigned chars of 1-\/4 components), then the cells are colored with these values. (If point colors are defined and cell colors are not, you can use vtk\-Point\-Data\-To\-Cell\-Data to convert the point colors to cell colors.) Otherwise, by default, the cells are set to the specified color. If Color\-Mode\-To\-Specified\-Color is set, then the primitives will all be set to this color. If Color\-Mode\-To\-Random\-Colors is set, each cell will be randomly assigned a color.  
\item {\ttfamily obj.\-Set\-Color\-Mode\-To\-Specified\-Color ()} -\/ Control how output polydata is colored. By default (Color\-Mode\-To\-Default), if per cell colors are defined (unsigned chars of 1-\/4 components), then the cells are colored with these values. (If point colors are defined and cell colors are not, you can use vtk\-Point\-Data\-To\-Cell\-Data to convert the point colors to cell colors.) Otherwise, by default, the cells are set to the specified color. If Color\-Mode\-To\-Specified\-Color is set, then the primitives will all be set to this color. If Color\-Mode\-To\-Random\-Colors is set, each cell will be randomly assigned a color.  
\item {\ttfamily obj.\-Set\-Color\-Mode\-To\-Random\-Colors ()} -\/ Control how output polydata is colored. By default (Color\-Mode\-To\-Default), if per cell colors are defined (unsigned chars of 1-\/4 components), then the cells are colored with these values. (If point colors are defined and cell colors are not, you can use vtk\-Point\-Data\-To\-Cell\-Data to convert the point colors to cell colors.) Otherwise, by default, the cells are set to the specified color. If Color\-Mode\-To\-Specified\-Color is set, then the primitives will all be set to this color. If Color\-Mode\-To\-Random\-Colors is set, each cell will be randomly assigned a color.  
\item {\ttfamily obj.\-Set\-Specified\-Color (float , float , float )} -\/ Set/\-Get the specified color to color the polydata cells. This color is only used when the color mode is set to Color\-Mode\-To\-Specified\-Color, or Color\-Mode\-To\-Default is set and no cell colors are specified. The specified color is specified as R\-G\-B values ranging from (0,1). (Note\-: C\-G\-M will map this color to the closest color it supports.)  
\item {\ttfamily obj.\-Set\-Specified\-Color (float a\mbox{[}3\mbox{]})} -\/ Set/\-Get the specified color to color the polydata cells. This color is only used when the color mode is set to Color\-Mode\-To\-Specified\-Color, or Color\-Mode\-To\-Default is set and no cell colors are specified. The specified color is specified as R\-G\-B values ranging from (0,1). (Note\-: C\-G\-M will map this color to the closest color it supports.)  
\item {\ttfamily float = obj. Get\-Specified\-Color ()} -\/ Set/\-Get the specified color to color the polydata cells. This color is only used when the color mode is set to Color\-Mode\-To\-Specified\-Color, or Color\-Mode\-To\-Default is set and no cell colors are specified. The specified color is specified as R\-G\-B values ranging from (0,1). (Note\-: C\-G\-M will map this color to the closest color it supports.)  
\end{DoxyItemize}\hypertarget{vtkio_vtkchacoreader}{}\section{vtk\-Chaco\-Reader}\label{vtkio_vtkchacoreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Chaco\-Reader is an unstructured grid source object that reads Chaco files. The reader D\-O\-E\-S N\-O\-T respond to piece requests. Chaco is a graph partitioning package developed at Sandia National Laboratories in the early 1990s. (\href{http://www.cs.sandia.gov/~bahendr/chaco.html}{\tt http\-://www.\-cs.\-sandia.\-gov/$\sim$bahendr/chaco.\-html})

Note that the Chaco \char`\"{}edges\char`\"{} become V\-T\-K \char`\"{}cells\char`\"{}, and the Chaco \char`\"{}vertices\char`\"{} become V\-T\-K \char`\"{}points\char`\"{}.

To create an instance of class vtk\-Chaco\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkChacoReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Chaco\-Reader 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\-Chaco\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Chaco\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Chaco\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Base\-Name (string )}  
\item {\ttfamily string = obj.\-Get\-Base\-Name ()}  
\item {\ttfamily obj.\-Set\-Generate\-Global\-Element\-Id\-Array (int )}  
\item {\ttfamily int = obj.\-Get\-Generate\-Global\-Element\-Id\-Array ()}  
\item {\ttfamily obj.\-Generate\-Global\-Element\-Id\-Array\-On ()}  
\item {\ttfamily obj.\-Generate\-Global\-Element\-Id\-Array\-Off ()}  
\item {\ttfamily obj.\-Set\-Generate\-Global\-Node\-Id\-Array (int )}  
\item {\ttfamily int = obj.\-Get\-Generate\-Global\-Node\-Id\-Array ()}  
\item {\ttfamily obj.\-Generate\-Global\-Node\-Id\-Array\-On ()}  
\item {\ttfamily obj.\-Generate\-Global\-Node\-Id\-Array\-Off ()}  
\item {\ttfamily obj.\-Set\-Generate\-Vertex\-Weight\-Arrays (int )}  
\item {\ttfamily int = obj.\-Get\-Generate\-Vertex\-Weight\-Arrays ()}  
\item {\ttfamily obj.\-Generate\-Vertex\-Weight\-Arrays\-On ()}  
\item {\ttfamily obj.\-Generate\-Vertex\-Weight\-Arrays\-Off ()}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Vertex\-Weights ()}  
\item {\ttfamily string = obj.\-Get\-Vertex\-Weight\-Array\-Name (int weight)}  
\item {\ttfamily obj.\-Set\-Generate\-Edge\-Weight\-Arrays (int )}  
\item {\ttfamily int = obj.\-Get\-Generate\-Edge\-Weight\-Arrays ()}  
\item {\ttfamily obj.\-Generate\-Edge\-Weight\-Arrays\-On ()}  
\item {\ttfamily obj.\-Generate\-Edge\-Weight\-Arrays\-Off ()}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Edge\-Weights ()}  
\item {\ttfamily string = obj.\-Get\-Edge\-Weight\-Array\-Name (int weight)}  
\item {\ttfamily int = obj.\-Get\-Dimensionality ()} -\/ Access to meta data generated by Request\-Information.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Edges ()} -\/ Access to meta data generated by Request\-Information.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Vertices ()} -\/ Access to meta data generated by Request\-Information.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Cell\-Weight\-Arrays ()}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Point\-Weight\-Arrays ()}  
\end{DoxyItemize}\hypertarget{vtkio_vtkdatacompressor}{}\section{vtk\-Data\-Compressor}\label{vtkio_vtkdatacompressor}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Data\-Compressor provides a universal interface for data compression. Subclasses provide one compression method and one decompression method. The public interface to all compressors remains the same, and is defined by this class.

To create an instance of class vtk\-Data\-Compressor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDataCompressor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Data\-Compressor 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\-Compressor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Data\-Compressor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Data\-Compressor = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily long = obj.\-Get\-Maximum\-Compression\-Space (long size)} -\/ Get the maximum space that may be needed to store data of the given uncompressed size after compression. This is the minimum size of the output buffer that can be passed to the four-\/argument Compress method.  
\item {\ttfamily long = obj.\-Compress (string uncompressed\-Data, long uncompressed\-Size, string compressed\-Data, long compression\-Space)} -\/ Compress the given input data buffer into the given output buffer. The size of the output buffer must be at least as large as the value given by Get\-Maximum\-Compression\-Space for the given input size.  
\item {\ttfamily long = obj.\-Uncompress (string compressed\-Data, long compressed\-Size, string uncompressed\-Data, long uncompressed\-Size)} -\/ Uncompress the given input data into the given output buffer. The size of the uncompressed data must be known by the caller. It should be transmitted from the compressor by a means outside of this class.  
\item {\ttfamily vtk\-Unsigned\-Char\-Array = obj.\-Compress (string uncompressed\-Data, long uncompressed\-Size)} -\/ Compress the given data. A vtk\-Unsigned\-Char\-Array containing the compressed data is returned with a reference count of 1.  
\item {\ttfamily vtk\-Unsigned\-Char\-Array = obj.\-Uncompress (string compressed\-Data, long compressed\-Size, long uncompressed\-Size)} -\/ Uncompress the given data. A vtk\-Unsigned\-Char\-Array containing the compressed data is returned with a reference count of 1. The size of the uncompressed data must be known by the caller. It should be transmitted from the compressor by a means outside of this class.  
\end{DoxyItemize}\hypertarget{vtkio_vtkdataobjectreader}{}\section{vtk\-Data\-Object\-Reader}\label{vtkio_vtkdataobjectreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Data\-Object\-Reader is a source object that reads A\-S\-C\-I\-I or binary field data files in vtk format. Fields are general matrix structures used represent complex data. (See text for format details). The output of this reader is a single vtk\-Data\-Object. The superclass of this class, vtk\-Data\-Reader, provides many methods for controlling the reading of the data file, see vtk\-Data\-Reader for more information.

To create an instance of class vtk\-Data\-Object\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDataObjectReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Data\-Object\-Reader 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\-Object\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Data\-Object\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Data\-Object\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Output ()} -\/ Get the output field of this reader.  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Output (int idx)} -\/ Get the output field of this reader.  
\item {\ttfamily obj.\-Set\-Output (vtk\-Data\-Object )} -\/ Get the output field of this reader.  
\end{DoxyItemize}\hypertarget{vtkio_vtkdataobjectwriter}{}\section{vtk\-Data\-Object\-Writer}\label{vtkio_vtkdataobjectwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Data\-Object\-Writer is a source object that writes A\-S\-C\-I\-I or binary field data files in vtk format. Field data is a general form of data in matrix form.

To create an instance of class vtk\-Data\-Object\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDataObjectWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Data\-Object\-Writer 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\-Object\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Data\-Object\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Data\-Object\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string filename)} -\/ Methods delegated to vtk\-Data\-Writer, see vtk\-Data\-Writer.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Methods delegated to vtk\-Data\-Writer, see vtk\-Data\-Writer.  
\item {\ttfamily obj.\-Set\-Header (string header)} -\/ Methods delegated to vtk\-Data\-Writer, see vtk\-Data\-Writer.  
\item {\ttfamily string = obj.\-Get\-Header ()} -\/ Methods delegated to vtk\-Data\-Writer, see vtk\-Data\-Writer.  
\item {\ttfamily obj.\-Set\-File\-Type (int type)} -\/ Methods delegated to vtk\-Data\-Writer, see vtk\-Data\-Writer.  
\item {\ttfamily int = obj.\-Get\-File\-Type ()} -\/ Methods delegated to vtk\-Data\-Writer, see vtk\-Data\-Writer.  
\item {\ttfamily obj.\-Set\-File\-Type\-To\-A\-S\-C\-I\-I ()} -\/ Methods delegated to vtk\-Data\-Writer, see vtk\-Data\-Writer.  
\item {\ttfamily obj.\-Set\-File\-Type\-To\-Binary ()} -\/ Methods delegated to vtk\-Data\-Writer, see vtk\-Data\-Writer.  
\item {\ttfamily obj.\-Set\-Field\-Data\-Name (string fieldname)} -\/ Methods delegated to vtk\-Data\-Writer, see vtk\-Data\-Writer.  
\item {\ttfamily string = obj.\-Get\-Field\-Data\-Name ()} -\/ Methods delegated to vtk\-Data\-Writer, see vtk\-Data\-Writer.  
\end{DoxyItemize}\hypertarget{vtkio_vtkdatareader}{}\section{vtk\-Data\-Reader}\label{vtkio_vtkdatareader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Data\-Reader is a helper superclass that reads the vtk data file header, dataset type, and attribute data (point and cell attributes such as scalars, vectors, normals, etc.) from a vtk data file. See text for the format of the various vtk file types.

To create an instance of class vtk\-Data\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDataReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Data\-Reader 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\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Data\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Data\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify file name of vtk data file to read.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify file name of vtk data file to read.  
\item {\ttfamily int = obj.\-Is\-File\-Valid (string dstype)} -\/ Is the file a valid vtk file of the passed dataset type ? The dataset type is passed as a lower case string.  
\item {\ttfamily int = obj.\-Is\-File\-Structured\-Points ()} -\/ Is the file a valid vtk file of the passed dataset type ? The dataset type is passed as a lower case string.  
\item {\ttfamily int = obj.\-Is\-File\-Poly\-Data ()} -\/ Is the file a valid vtk file of the passed dataset type ? The dataset type is passed as a lower case string.  
\item {\ttfamily int = obj.\-Is\-File\-Structured\-Grid ()} -\/ Is the file a valid vtk file of the passed dataset type ? The dataset type is passed as a lower case string.  
\item {\ttfamily int = obj.\-Is\-File\-Unstructured\-Grid ()} -\/ Is the file a valid vtk file of the passed dataset type ? The dataset type is passed as a lower case string.  
\item {\ttfamily int = obj.\-Is\-File\-Rectilinear\-Grid ()} -\/ Is the file a valid vtk file of the passed dataset type ? The dataset type is passed as a lower case string.  
\item {\ttfamily obj.\-Set\-Input\-String (string in)} -\/ Specify the Input\-String for use when reading from a character array. Optionally include the length for binary strings. Note that a copy of the string is made and stored. If this causes exceedingly large memory consumption, consider using Input\-Array instead.  
\item {\ttfamily string = obj.\-Get\-Input\-String ()} -\/ Specify the Input\-String for use when reading from a character array. Optionally include the length for binary strings. Note that a copy of the string is made and stored. If this causes exceedingly large memory consumption, consider using Input\-Array instead.  
\item {\ttfamily obj.\-Set\-Input\-String (string in, int len)} -\/ Specify the Input\-String for use when reading from a character array. Optionally include the length for binary strings. Note that a copy of the string is made and stored. If this causes exceedingly large memory consumption, consider using Input\-Array instead.  
\item {\ttfamily int = obj.\-Get\-Input\-String\-Length ()} -\/ Specify the Input\-String for use when reading from a character array. Optionally include the length for binary strings. Note that a copy of the string is made and stored. If this causes exceedingly large memory consumption, consider using Input\-Array instead.  
\item {\ttfamily obj.\-Set\-Binary\-Input\-String (string , int len)} -\/ Specify the Input\-String for use when reading from a character array. Optionally include the length for binary strings. Note that a copy of the string is made and stored. If this causes exceedingly large memory consumption, consider using Input\-Array instead.  
\item {\ttfamily obj.\-Set\-Input\-Array (vtk\-Char\-Array )} -\/ Specify the vtk\-Char\-Array to be used when reading from a string. If set, this array has precendence over Input\-String. Use this instead of Input\-String to avoid the extra memory copy. It should be noted that if the underlying char$\ast$ is owned by the user ( vtk\-Char\-Array\-::\-Set\-Array(array, 1); ) and is deleted before the reader, bad things will happen during a pipeline update.  
\item {\ttfamily vtk\-Char\-Array = obj.\-Get\-Input\-Array ()} -\/ Specify the vtk\-Char\-Array to be used when reading from a string. If set, this array has precendence over Input\-String. Use this instead of Input\-String to avoid the extra memory copy. It should be noted that if the underlying char$\ast$ is owned by the user ( vtk\-Char\-Array\-::\-Set\-Array(array, 1); ) and is deleted before the reader, bad things will happen during a pipeline update.  
\item {\ttfamily string = obj.\-Get\-Header ()} -\/ Get the header from the vtk data file.  
\item {\ttfamily obj.\-Set\-Read\-From\-Input\-String (int )} -\/ Enable reading from an Input\-String or Input\-Array instead of the default, a file.  
\item {\ttfamily int = obj.\-Get\-Read\-From\-Input\-String ()} -\/ Enable reading from an Input\-String or Input\-Array instead of the default, a file.  
\item {\ttfamily obj.\-Read\-From\-Input\-String\-On ()} -\/ Enable reading from an Input\-String or Input\-Array instead of the default, a file.  
\item {\ttfamily obj.\-Read\-From\-Input\-String\-Off ()} -\/ Enable reading from an Input\-String or Input\-Array instead of the default, a file.  
\item {\ttfamily int = obj.\-Get\-File\-Type ()} -\/ Get the type of file (A\-S\-C\-I\-I or B\-I\-N\-A\-R\-Y). Returned value only valid after file has been read.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Scalars\-In\-File ()} -\/ How many attributes of various types are in this file? This requires reading the file, so the filename must be set prior to invoking this operation. (Note\-: file characteristics are cached, so only a single read is necessary to return file characteristics.)  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Vectors\-In\-File ()} -\/ How many attributes of various types are in this file? This requires reading the file, so the filename must be set prior to invoking this operation. (Note\-: file characteristics are cached, so only a single read is necessary to return file characteristics.)  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Tensors\-In\-File ()} -\/ How many attributes of various types are in this file? This requires reading the file, so the filename must be set prior to invoking this operation. (Note\-: file characteristics are cached, so only a single read is necessary to return file characteristics.)  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Normals\-In\-File ()} -\/ How many attributes of various types are in this file? This requires reading the file, so the filename must be set prior to invoking this operation. (Note\-: file characteristics are cached, so only a single read is necessary to return file characteristics.)  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-T\-Coords\-In\-File ()} -\/ How many attributes of various types are in this file? This requires reading the file, so the filename must be set prior to invoking this operation. (Note\-: file characteristics are cached, so only a single read is necessary to return file characteristics.)  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Field\-Data\-In\-File ()} -\/ What is the name of the ith attribute of a certain type in this file? This requires reading the file, so the filename must be set prior to invoking this operation.  
\item {\ttfamily string = obj.\-Get\-Scalars\-Name\-In\-File (int i)} -\/ What is the name of the ith attribute of a certain type in this file? This requires reading the file, so the filename must be set prior to invoking this operation.  
\item {\ttfamily string = obj.\-Get\-Vectors\-Name\-In\-File (int i)} -\/ What is the name of the ith attribute of a certain type in this file? This requires reading the file, so the filename must be set prior to invoking this operation.  
\item {\ttfamily string = obj.\-Get\-Tensors\-Name\-In\-File (int i)} -\/ What is the name of the ith attribute of a certain type in this file? This requires reading the file, so the filename must be set prior to invoking this operation.  
\item {\ttfamily string = obj.\-Get\-Normals\-Name\-In\-File (int i)} -\/ What is the name of the ith attribute of a certain type in this file? This requires reading the file, so the filename must be set prior to invoking this operation.  
\item {\ttfamily string = obj.\-Get\-T\-Coords\-Name\-In\-File (int i)} -\/ What is the name of the ith attribute of a certain type in this file? This requires reading the file, so the filename must be set prior to invoking this operation.  
\item {\ttfamily string = obj.\-Get\-Field\-Data\-Name\-In\-File (int i)} -\/ What is the name of the ith attribute of a certain type in this file? This requires reading the file, so the filename must be set prior to invoking this operation.  
\item {\ttfamily obj.\-Set\-Scalars\-Name (string )} -\/ Set the name of the scalar data to extract. If not specified, first scalar data encountered is extracted.  
\item {\ttfamily string = obj.\-Get\-Scalars\-Name ()} -\/ Set the name of the scalar data to extract. If not specified, first scalar data encountered is extracted.  
\item {\ttfamily obj.\-Set\-Vectors\-Name (string )} -\/ Set the name of the vector data to extract. If not specified, first vector data encountered is extracted.  
\item {\ttfamily string = obj.\-Get\-Vectors\-Name ()} -\/ Set the name of the vector data to extract. If not specified, first vector data encountered is extracted.  
\item {\ttfamily obj.\-Set\-Tensors\-Name (string )} -\/ Set the name of the tensor data to extract. If not specified, first tensor data encountered is extracted.  
\item {\ttfamily string = obj.\-Get\-Tensors\-Name ()} -\/ Set the name of the tensor data to extract. If not specified, first tensor data encountered is extracted.  
\item {\ttfamily obj.\-Set\-Normals\-Name (string )} -\/ Set the name of the normal data to extract. If not specified, first normal data encountered is extracted.  
\item {\ttfamily string = obj.\-Get\-Normals\-Name ()} -\/ Set the name of the normal data to extract. If not specified, first normal data encountered is extracted.  
\item {\ttfamily obj.\-Set\-T\-Coords\-Name (string )} -\/ Set the name of the texture coordinate data to extract. If not specified, first texture coordinate data encountered is extracted.  
\item {\ttfamily string = obj.\-Get\-T\-Coords\-Name ()} -\/ Set the name of the texture coordinate data to extract. If not specified, first texture coordinate data encountered is extracted.  
\item {\ttfamily obj.\-Set\-Lookup\-Table\-Name (string )} -\/ Set the name of the lookup table data to extract. If not specified, uses lookup table named by scalar. Otherwise, this specification supersedes.  
\item {\ttfamily string = obj.\-Get\-Lookup\-Table\-Name ()} -\/ Set the name of the lookup table data to extract. If not specified, uses lookup table named by scalar. Otherwise, this specification supersedes.  
\item {\ttfamily obj.\-Set\-Field\-Data\-Name (string )} -\/ Set the name of the field data to extract. If not specified, uses first field data encountered in file.  
\item {\ttfamily string = obj.\-Get\-Field\-Data\-Name ()} -\/ Set the name of the field data to extract. If not specified, uses first field data encountered in file.  
\item {\ttfamily obj.\-Set\-Read\-All\-Scalars (int )} -\/ Enable reading all scalars.  
\item {\ttfamily int = obj.\-Get\-Read\-All\-Scalars ()} -\/ Enable reading all scalars.  
\item {\ttfamily obj.\-Read\-All\-Scalars\-On ()} -\/ Enable reading all scalars.  
\item {\ttfamily obj.\-Read\-All\-Scalars\-Off ()} -\/ Enable reading all scalars.  
\item {\ttfamily obj.\-Set\-Read\-All\-Vectors (int )} -\/ Enable reading all vectors.  
\item {\ttfamily int = obj.\-Get\-Read\-All\-Vectors ()} -\/ Enable reading all vectors.  
\item {\ttfamily obj.\-Read\-All\-Vectors\-On ()} -\/ Enable reading all vectors.  
\item {\ttfamily obj.\-Read\-All\-Vectors\-Off ()} -\/ Enable reading all vectors.  
\item {\ttfamily obj.\-Set\-Read\-All\-Normals (int )} -\/ Enable reading all normals.  
\item {\ttfamily int = obj.\-Get\-Read\-All\-Normals ()} -\/ Enable reading all normals.  
\item {\ttfamily obj.\-Read\-All\-Normals\-On ()} -\/ Enable reading all normals.  
\item {\ttfamily obj.\-Read\-All\-Normals\-Off ()} -\/ Enable reading all normals.  
\item {\ttfamily obj.\-Set\-Read\-All\-Tensors (int )} -\/ Enable reading all tensors.  
\item {\ttfamily int = obj.\-Get\-Read\-All\-Tensors ()} -\/ Enable reading all tensors.  
\item {\ttfamily obj.\-Read\-All\-Tensors\-On ()} -\/ Enable reading all tensors.  
\item {\ttfamily obj.\-Read\-All\-Tensors\-Off ()} -\/ Enable reading all tensors.  
\item {\ttfamily obj.\-Set\-Read\-All\-Color\-Scalars (int )} -\/ Enable reading all color scalars.  
\item {\ttfamily int = obj.\-Get\-Read\-All\-Color\-Scalars ()} -\/ Enable reading all color scalars.  
\item {\ttfamily obj.\-Read\-All\-Color\-Scalars\-On ()} -\/ Enable reading all color scalars.  
\item {\ttfamily obj.\-Read\-All\-Color\-Scalars\-Off ()} -\/ Enable reading all color scalars.  
\item {\ttfamily obj.\-Set\-Read\-All\-T\-Coords (int )} -\/ Enable reading all tcoords.  
\item {\ttfamily int = obj.\-Get\-Read\-All\-T\-Coords ()} -\/ Enable reading all tcoords.  
\item {\ttfamily obj.\-Read\-All\-T\-Coords\-On ()} -\/ Enable reading all tcoords.  
\item {\ttfamily obj.\-Read\-All\-T\-Coords\-Off ()} -\/ Enable reading all tcoords.  
\item {\ttfamily obj.\-Set\-Read\-All\-Fields (int )} -\/ Enable reading all fields.  
\item {\ttfamily int = obj.\-Get\-Read\-All\-Fields ()} -\/ Enable reading all fields.  
\item {\ttfamily obj.\-Read\-All\-Fields\-On ()} -\/ Enable reading all fields.  
\item {\ttfamily obj.\-Read\-All\-Fields\-Off ()} -\/ Enable reading all fields.  
\item {\ttfamily int = obj.\-Open\-V\-T\-K\-File ()} -\/ Open a vtk data file. Returns zero if error.  
\item {\ttfamily int = obj.\-Read\-Header ()} -\/ Read the header of a vtk data file. Returns 0 if error.  
\item {\ttfamily int = obj.\-Read\-Cell\-Data (vtk\-Data\-Set ds, int num\-Cells)} -\/ Read the cell data of a vtk data file. The number of cells (from the dataset) must match the number of cells defined in cell attributes (unless no geometry was defined).  
\item {\ttfamily int = obj.\-Read\-Point\-Data (vtk\-Data\-Set ds, int num\-Pts)} -\/ Read the point data of a vtk data file. The number of points (from the dataset) must match the number of points defined in point attributes (unless no geometry was defined).  
\item {\ttfamily int = obj.\-Read\-Points (vtk\-Point\-Set ps, int num\-Pts)} -\/ Read point coordinates. Return 0 if error.  
\item {\ttfamily int = obj.\-Read\-Points (vtk\-Graph g, int num\-Pts)} -\/ Read point coordinates. Return 0 if error.  
\item {\ttfamily int = obj.\-Read\-Vertex\-Data (vtk\-Graph g, int num\-Vertices)} -\/ Read the vertex data of a vtk data file. The number of vertices (from the graph) must match the number of vertices defined in vertex attributes (unless no geometry was defined).  
\item {\ttfamily int = obj.\-Read\-Edge\-Data (vtk\-Graph g, int num\-Edges)} -\/ Read the edge data of a vtk data file. The number of edges (from the graph) must match the number of edges defined in edge attributes (unless no geometry was defined).  
\item {\ttfamily int = obj.\-Read\-Row\-Data (vtk\-Table t, int num\-Edges)} -\/ Read the row data of a vtk data file.  
\item {\ttfamily int = obj.\-Read\-Cells (int size, int data)} -\/ Read a bunch of \char`\"{}cells\char`\"{}. Return 0 if error.  
\item {\ttfamily int = obj.\-Read\-Cells (int size, int data, int skip1, int read2, int skip3)} -\/ Read a piece of the cells (for streaming compliance)  
\item {\ttfamily int = obj.\-Read\-Coordinates (vtk\-Rectilinear\-Grid rg, int axes, int num\-Coords)} -\/ Read the coordinates for a rectilinear grid. The axes parameter specifies which coordinate axes (0,1,2) is being read.  
\item {\ttfamily vtk\-Abstract\-Array = obj.\-Read\-Array (string data\-Type, int num\-Tuples, int num\-Comp)} -\/ Helper functions for reading data.  
\item {\ttfamily vtk\-Field\-Data = obj.\-Read\-Field\-Data ()} -\/ Helper functions for reading data.  
\item {\ttfamily obj.\-Close\-V\-T\-K\-File ()} -\/ Close the vtk file.  
\item {\ttfamily int = obj.\-Read\-Meta\-Data (vtk\-Information )}  
\end{DoxyItemize}\hypertarget{vtkio_vtkdatasetreader}{}\section{vtk\-Data\-Set\-Reader}\label{vtkio_vtkdatasetreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Data\-Set\-Reader is a class that provides instance variables and methods to read any type of dataset in Visualization Toolkit (vtk) format. The output type of this class will vary depending upon the type of data file. Convenience methods are provided to keep the data as a particular type. (See text for format description details). The superclass of this class, vtk\-Data\-Reader, provides many methods for controlling the reading of the data file, see vtk\-Data\-Reader for more information.

To create an instance of class vtk\-Data\-Set\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDataSetReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Data\-Set\-Reader 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\-Set\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Data\-Set\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Data\-Set\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Output ()} -\/ Get the output of this filter  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Output (int idx)} -\/ Get the output of this filter  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Poly\-Data\-Output ()} -\/ Get the output as various concrete types. This method is typically used when you know exactly what type of data is being read. Otherwise, use the general Get\-Output() method. If the wrong type is used N\-U\-L\-L is returned. (You must also set the filename of the object prior to getting the output.)  
\item {\ttfamily vtk\-Structured\-Points = obj.\-Get\-Structured\-Points\-Output ()} -\/ Get the output as various concrete types. This method is typically used when you know exactly what type of data is being read. Otherwise, use the general Get\-Output() method. If the wrong type is used N\-U\-L\-L is returned. (You must also set the filename of the object prior to getting the output.)  
\item {\ttfamily vtk\-Structured\-Grid = obj.\-Get\-Structured\-Grid\-Output ()} -\/ Get the output as various concrete types. This method is typically used when you know exactly what type of data is being read. Otherwise, use the general Get\-Output() method. If the wrong type is used N\-U\-L\-L is returned. (You must also set the filename of the object prior to getting the output.)  
\item {\ttfamily vtk\-Unstructured\-Grid = obj.\-Get\-Unstructured\-Grid\-Output ()} -\/ Get the output as various concrete types. This method is typically used when you know exactly what type of data is being read. Otherwise, use the general Get\-Output() method. If the wrong type is used N\-U\-L\-L is returned. (You must also set the filename of the object prior to getting the output.)  
\item {\ttfamily vtk\-Rectilinear\-Grid = obj.\-Get\-Rectilinear\-Grid\-Output ()} -\/ Get the output as various concrete types. This method is typically used when you know exactly what type of data is being read. Otherwise, use the general Get\-Output() method. If the wrong type is used N\-U\-L\-L is returned. (You must also set the filename of the object prior to getting the output.)  
\item {\ttfamily int = obj.\-Read\-Output\-Type ()} -\/ This method can be used to find out the type of output expected without needing to read the whole file.  
\end{DoxyItemize}\hypertarget{vtkio_vtkdatasetwriter}{}\section{vtk\-Data\-Set\-Writer}\label{vtkio_vtkdatasetwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Data\-Set\-Writer is an abstract class for mapper objects that write their data to disk (or into a communications port). The input to this object is a dataset of any type.

To create an instance of class vtk\-Data\-Set\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDataSetWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Data\-Set\-Writer 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\-Set\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Data\-Set\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Data\-Set\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Input ()} -\/ Get the input to this writer.  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Input (int port)} -\/ Get the input to this writer.  
\end{DoxyItemize}\hypertarget{vtkio_vtkdatawriter}{}\section{vtk\-Data\-Writer}\label{vtkio_vtkdatawriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Data\-Writer is a helper class that opens and writes the vtk header and point data (e.\-g., scalars, vectors, normals, etc.) from a vtk data file. See text for various formats.

To create an instance of class vtk\-Data\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDataWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Data\-Writer 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\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Data\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Data\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify file name of vtk polygon data file to write.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify file name of vtk polygon data file to write.  
\item {\ttfamily obj.\-Set\-Write\-To\-Output\-String (int )} -\/ Enable writing to an Output\-String instead of the default, a file.  
\item {\ttfamily int = obj.\-Get\-Write\-To\-Output\-String ()} -\/ Enable writing to an Output\-String instead of the default, a file.  
\item {\ttfamily obj.\-Write\-To\-Output\-String\-On ()} -\/ Enable writing to an Output\-String instead of the default, a file.  
\item {\ttfamily obj.\-Write\-To\-Output\-String\-Off ()} -\/ Enable writing to an Output\-String instead of the default, a file.  
\item {\ttfamily int = obj.\-Get\-Output\-String\-Length ()} -\/ When Write\-To\-Output\-String in on, then a string is allocated, written to, and can be retrieved with these methods. The string is deleted during the next call to write ...  
\item {\ttfamily string = obj.\-Get\-Output\-String ()} -\/ When Write\-To\-Output\-String in on, then a string is allocated, written to, and can be retrieved with these methods. The string is deleted during the next call to write ...  
\item {\ttfamily string = obj.\-Register\-And\-Get\-Output\-String ()} -\/ This convenience method returns the string, sets the I\-V\-A\-R to N\-U\-L\-L, so that the user is responsible for deleting the string. I am not sure what the name should be, so it may change in the future.  
\item {\ttfamily obj.\-Set\-Header (string )} -\/ Specify the header for the vtk data file.  
\item {\ttfamily string = obj.\-Get\-Header ()} -\/ Specify the header for the vtk data file.  
\item {\ttfamily obj.\-Set\-File\-Type (int )} -\/ Specify file type (A\-S\-C\-I\-I or B\-I\-N\-A\-R\-Y) for vtk data file.  
\item {\ttfamily int = obj.\-Get\-File\-Type\-Min\-Value ()} -\/ Specify file type (A\-S\-C\-I\-I or B\-I\-N\-A\-R\-Y) for vtk data file.  
\item {\ttfamily int = obj.\-Get\-File\-Type\-Max\-Value ()} -\/ Specify file type (A\-S\-C\-I\-I or B\-I\-N\-A\-R\-Y) for vtk data file.  
\item {\ttfamily int = obj.\-Get\-File\-Type ()} -\/ Specify file type (A\-S\-C\-I\-I or B\-I\-N\-A\-R\-Y) for vtk data file.  
\item {\ttfamily obj.\-Set\-File\-Type\-To\-A\-S\-C\-I\-I ()} -\/ Specify file type (A\-S\-C\-I\-I or B\-I\-N\-A\-R\-Y) for vtk data file.  
\item {\ttfamily obj.\-Set\-File\-Type\-To\-Binary ()} -\/ Specify file type (A\-S\-C\-I\-I or B\-I\-N\-A\-R\-Y) for vtk data file.  
\item {\ttfamily obj.\-Set\-Scalars\-Name (string )} -\/ Give a name to the scalar data. If not specified, uses default name \char`\"{}scalars\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-Scalars\-Name ()} -\/ Give a name to the scalar data. If not specified, uses default name \char`\"{}scalars\char`\"{}.  
\item {\ttfamily obj.\-Set\-Vectors\-Name (string )} -\/ Give a name to the vector data. If not specified, uses default name \char`\"{}vectors\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-Vectors\-Name ()} -\/ Give a name to the vector data. If not specified, uses default name \char`\"{}vectors\char`\"{}.  
\item {\ttfamily obj.\-Set\-Tensors\-Name (string )} -\/ Give a name to the tensors data. If not specified, uses default name \char`\"{}tensors\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-Tensors\-Name ()} -\/ Give a name to the tensors data. If not specified, uses default name \char`\"{}tensors\char`\"{}.  
\item {\ttfamily obj.\-Set\-Normals\-Name (string )} -\/ Give a name to the normals data. If not specified, uses default name \char`\"{}normals\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-Normals\-Name ()} -\/ Give a name to the normals data. If not specified, uses default name \char`\"{}normals\char`\"{}.  
\item {\ttfamily obj.\-Set\-T\-Coords\-Name (string )} -\/ Give a name to the texture coordinates data. If not specified, uses default name \char`\"{}texture\-Coords\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-T\-Coords\-Name ()} -\/ Give a name to the texture coordinates data. If not specified, uses default name \char`\"{}texture\-Coords\char`\"{}.  
\item {\ttfamily obj.\-Set\-Global\-Ids\-Name (string )} -\/ Give a name to the global ids data. If not specified, uses default name \char`\"{}global\-\_\-ids\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-Global\-Ids\-Name ()} -\/ Give a name to the global ids data. If not specified, uses default name \char`\"{}global\-\_\-ids\char`\"{}.  
\item {\ttfamily obj.\-Set\-Pedigree\-Ids\-Name (string )} -\/ Give a name to the pedigree ids data. If not specified, uses default name \char`\"{}pedigree\-\_\-ids\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-Pedigree\-Ids\-Name ()} -\/ Give a name to the pedigree ids data. If not specified, uses default name \char`\"{}pedigree\-\_\-ids\char`\"{}.  
\item {\ttfamily obj.\-Set\-Lookup\-Table\-Name (string )} -\/ Give a name to the lookup table. If not specified, uses default name \char`\"{}lookup\-Table\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-Lookup\-Table\-Name ()} -\/ Give a name to the lookup table. If not specified, uses default name \char`\"{}lookup\-Table\char`\"{}.  
\item {\ttfamily obj.\-Set\-Field\-Data\-Name (string )} -\/ Give a name to the field data. If not specified, uses default name \char`\"{}field\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-Field\-Data\-Name ()} -\/ Give a name to the field data. If not specified, uses default name \char`\"{}field\char`\"{}.  
\end{DoxyItemize}\hypertarget{vtkio_vtkdemreader}{}\section{vtk\-D\-E\-M\-Reader}\label{vtkio_vtkdemreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-D\-E\-M\-Reader reads digital elevation files and creates image data. Digital elevation files are produced by the \href{http://www.usgs.gov}{\tt U\-S Geological Survey}. A complete description of the D\-E\-M file is located at the U\-S\-G\-S site. The reader reads the entire dem file and create a vtk\-Image\-Data that contains a single scalar component that is the elevation in meters. The spacing is also expressed in meters. A number of get methods provide access to fields on the header.

To create an instance of class vtk\-D\-E\-M\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDEMReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-D\-E\-M\-Reader 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\-D\-E\-M\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-D\-E\-M\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-D\-E\-M\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify file name of Digital Elevation Model (D\-E\-M) file  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify file name of Digital Elevation Model (D\-E\-M) file  
\item {\ttfamily obj.\-Set\-Elevation\-Reference (int )} -\/ Specify the elevation origin to use. By default, the elevation origin is equal to Elevation\-Bounds\mbox{[}0\mbox{]}. A more convenient origin is to use sea level (i.\-e., a value of 0.\-0).  
\item {\ttfamily int = obj.\-Get\-Elevation\-Reference\-Min\-Value ()} -\/ Specify the elevation origin to use. By default, the elevation origin is equal to Elevation\-Bounds\mbox{[}0\mbox{]}. A more convenient origin is to use sea level (i.\-e., a value of 0.\-0).  
\item {\ttfamily int = obj.\-Get\-Elevation\-Reference\-Max\-Value ()} -\/ Specify the elevation origin to use. By default, the elevation origin is equal to Elevation\-Bounds\mbox{[}0\mbox{]}. A more convenient origin is to use sea level (i.\-e., a value of 0.\-0).  
\item {\ttfamily int = obj.\-Get\-Elevation\-Reference ()} -\/ Specify the elevation origin to use. By default, the elevation origin is equal to Elevation\-Bounds\mbox{[}0\mbox{]}. A more convenient origin is to use sea level (i.\-e., a value of 0.\-0).  
\item {\ttfamily obj.\-Set\-Elevation\-Reference\-To\-Sea\-Level ()} -\/ Specify the elevation origin to use. By default, the elevation origin is equal to Elevation\-Bounds\mbox{[}0\mbox{]}. A more convenient origin is to use sea level (i.\-e., a value of 0.\-0).  
\item {\ttfamily obj.\-Set\-Elevation\-Reference\-To\-Elevation\-Bounds ()} -\/ Specify the elevation origin to use. By default, the elevation origin is equal to Elevation\-Bounds\mbox{[}0\mbox{]}. A more convenient origin is to use sea level (i.\-e., a value of 0.\-0).  
\item {\ttfamily string = obj.\-Get\-Elevation\-Reference\-As\-String (void )} -\/ Specify the elevation origin to use. By default, the elevation origin is equal to Elevation\-Bounds\mbox{[}0\mbox{]}. A more convenient origin is to use sea level (i.\-e., a value of 0.\-0).  
\item {\ttfamily string = obj.\-Get\-Map\-Label ()} -\/ An A\-S\-C\-I\-I description of the map  
\item {\ttfamily int = obj.\-Get\-D\-E\-M\-Level ()} -\/ Code 1=D\-E\-M-\/1, 2=D\-E\-M\-\_\-2, ...  
\item {\ttfamily int = obj.\-Get\-Elevation\-Pattern ()} -\/ Code 1=regular, 2=random, reserved for future use  
\item {\ttfamily int = obj.\-Get\-Ground\-System ()} -\/ Ground planimetric reference system  
\item {\ttfamily int = obj.\-Get\-Ground\-Zone ()} -\/ Zone in ground planimetric reference system  
\item {\ttfamily float = obj. Get\-Projection\-Parameters ()} -\/ Map Projection parameters. All are zero.  
\item {\ttfamily int = obj.\-Get\-Plane\-Unit\-Of\-Measure ()} -\/ Defining unit of measure for ground planimetric coordinates throughout the file. 0 = radians, 1 = feet, 2 = meters, 3 = arc-\/seconds.  
\item {\ttfamily int = obj.\-Get\-Elevation\-Unit\-Of\-Measure ()} -\/ Defining unit of measure for elevation coordinates throughout the file. 1 = feet, 2 = meters  
\item {\ttfamily int = obj.\-Get\-Polygon\-Size ()} -\/ Number of sides in the polygon which defines the coverage of the D\-E\-M file. Set to 4.  
\item {\ttfamily float = obj. Get\-Elevation\-Bounds ()} -\/ Minimum and maximum elevation for the D\-E\-M. The units in the file are in Elevation\-Unit\-Of\-Measure. This class converts them to meters.  
\item {\ttfamily float = obj.\-Get\-Local\-Rotation ()} -\/ Counterclockwise angle (in radians) from the primary axis of the planimetric reference to the primary axis of the D\-E\-M local reference system. I\-G\-N\-O\-R\-E\-D B\-Y T\-H\-I\-S I\-M\-P\-L\-E\-M\-E\-N\-T\-A\-T\-I\-O\-N.  
\item {\ttfamily int = obj.\-Get\-Accuracy\-Code ()} -\/ Accuracy code for elevations. 0=unknown accuracy  
\item {\ttfamily float = obj. Get\-Spatial\-Resolution ()} -\/ D\-E\-M spatial resolution for x,y,z. Values are expressed in units of resolution. Since elevations are read as integers, this permits fractional elevations.  
\item {\ttfamily int = obj. Get\-Profile\-Dimension ()} -\/ The number of rows and columns in the D\-E\-M.  
\end{DoxyItemize}\hypertarget{vtkio_vtkdicomimagereader}{}\section{vtk\-D\-I\-C\-O\-M\-Image\-Reader}\label{vtkio_vtkdicomimagereader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
D\-I\-C\-O\-M (stands for Digital Imaging in C\-Ommunications and Medicine) is a medical image file format widely used to exchange data, provided by various modalities. .S\-E\-C\-T\-I\-O\-N Warnings This reader might eventually handle A\-C\-R-\/\-N\-E\-M\-A file (predecessor of the D\-I\-C\-O\-M format for medical images). This reader does not handle encapsulated format, only plain raw file are handled. This reader also does not handle multi-\/frames D\-I\-C\-O\-M datasets. .S\-E\-C\-T\-I\-O\-N Warnings Internally D\-I\-C\-O\-M\-Parser assumes the x,y pixel spacing is stored in 0028,0030 and that z spacing is stored in Slice Thickness (correct only when slice were acquired contiguous)\-: 0018,0050. Which means this is only valid for some rare M\-R Image Storage

To create an instance of class vtk\-D\-I\-C\-O\-M\-Image\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDICOMImageReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-D\-I\-C\-O\-M\-Image\-Reader 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\-D\-I\-C\-O\-M\-Image\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Static method for construction.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Static method for construction.  
\item {\ttfamily vtk\-D\-I\-C\-O\-M\-Image\-Reader = obj.\-New\-Instance ()} -\/ Static method for construction.  
\item {\ttfamily vtk\-D\-I\-C\-O\-M\-Image\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Static method for construction.  
\item {\ttfamily obj.\-Set\-File\-Name (string fn)} -\/ Set the directory name for the reader to look in for D\-I\-C\-O\-M files. If this method is used, the reader will try to find all the D\-I\-C\-O\-M files in a directory. It will select the subset corresponding to the first series U\-I\-D it stumbles across and it will try to build an ordered volume from them based on the slice number. The volume building will be upgraded to something more sophisticated in the future.  
\item {\ttfamily obj.\-Set\-Directory\-Name (string dn)} -\/ Set the directory name for the reader to look in for D\-I\-C\-O\-M files. If this method is used, the reader will try to find all the D\-I\-C\-O\-M files in a directory. It will select the subset corresponding to the first series U\-I\-D it stumbles across and it will try to build an ordered volume from them based on the slice number. The volume building will be upgraded to something more sophisticated in the future.  
\item {\ttfamily string = obj.\-Get\-Directory\-Name ()} -\/ Returns the directory name.  
\item {\ttfamily double = obj.\-Get\-Pixel\-Spacing ()} -\/ Returns the pixel spacing (in X, Y, Z). Note\-: if there is only one slice, the Z spacing is set to the slice thickness. If there is more than one slice, it is set to the distance between the first two slices.  
\item {\ttfamily int = obj.\-Get\-Width ()} -\/ Returns the image width.  
\item {\ttfamily int = obj.\-Get\-Height ()} -\/ Returns the image height.  
\item {\ttfamily float = obj.\-Get\-Image\-Position\-Patient ()} -\/ Get the (D\-I\-C\-O\-M) x,y,z coordinates of the first pixel in the image (upper left hand corner) of the last image processed by the D\-I\-C\-O\-M\-Parser  
\item {\ttfamily float = obj.\-Get\-Image\-Orientation\-Patient ()} -\/ Get the (D\-I\-C\-O\-M) directions cosines. It consist of the components of the first two vectors. The third vector needs to be computed to form an orthonormal basis.  
\item {\ttfamily int = obj.\-Get\-Bits\-Allocated ()} -\/ Get the number of bits allocated for each pixel in the file.  
\item {\ttfamily int = obj.\-Get\-Pixel\-Representation ()} -\/ Get the pixel representation of the last image processed by the D\-I\-C\-O\-M\-Parser. A zero is a unsigned quantity. A one indicates a signed quantity  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components ()} -\/ Get the number of components of the image data for the last image processed.  
\item {\ttfamily string = obj.\-Get\-Transfer\-Syntax\-U\-I\-D ()} -\/ Get the transfer syntax U\-I\-D for the last image processed.  
\item {\ttfamily float = obj.\-Get\-Rescale\-Slope ()} -\/ Get the rescale slope for the pixel data.  
\item {\ttfamily float = obj.\-Get\-Rescale\-Offset ()} -\/ Get the rescale offset for the pixel data.  
\item {\ttfamily string = obj.\-Get\-Patient\-Name ()} -\/ Get the patient name for the last image processed.  
\item {\ttfamily string = obj.\-Get\-Study\-U\-I\-D ()} -\/ Get the study uid for the last image processed.  
\item {\ttfamily string = obj.\-Get\-Study\-I\-D ()} -\/ Get the Study I\-D for the last image processed.  
\item {\ttfamily float = obj.\-Get\-Gantry\-Angle ()} -\/ Get the gantry angle for the last image processed.  
\item {\ttfamily int = obj.\-Can\-Read\-File (string fname)}  
\item {\ttfamily string = obj.\-Get\-File\-Extensions ()} -\/ Return a descriptive name for the file format that might be useful in a G\-U\-I.  
\item {\ttfamily string = obj.\-Get\-Descriptive\-Name ()}  
\end{DoxyItemize}\hypertarget{vtkio_vtkensight6binaryreader}{}\section{vtk\-En\-Sight6\-Binary\-Reader}\label{vtkio_vtkensight6binaryreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-En\-Sight6\-Binary\-Reader is a class to read binary En\-Sight6 files into vtk. Because the different parts of the En\-Sight data can be of various data types, this reader produces multiple outputs, one per part in the input file. All variable information is being stored in field data. The descriptions listed in the case file are used as the array names in the field data. For complex vector variables, the description is appended with \-\_\-r (for the array of real values) and \-\_\-i (for the array if imaginary values). Complex scalar variables are stored as a single array with 2 components, real and imaginary, listed in that order.

To create an instance of class vtk\-En\-Sight6\-Binary\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkEnSight6BinaryReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-En\-Sight6\-Binary\-Reader 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\-En\-Sight6\-Binary\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-En\-Sight6\-Binary\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-En\-Sight6\-Binary\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkensight6reader}{}\section{vtk\-En\-Sight6\-Reader}\label{vtkio_vtkensight6reader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-En\-Sight6\-Reader is a class to read En\-Sight6 files into vtk. Because the different parts of the En\-Sight data can be of various data types, this reader produces multiple outputs, one per part in the input file. All variable information is being stored in field data. The descriptions listed in the case file are used as the array names in the field data. For complex vector variables, the description is appended with \-\_\-r (for the array of real values) and \-\_\-i (for the array if imaginary values). Complex scalar variables are stored as a single array with 2 components, real and imaginary, listed in that order.

To create an instance of class vtk\-En\-Sight6\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkEnSight6Reader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-En\-Sight6\-Reader 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\-En\-Sight6\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-En\-Sight6\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-En\-Sight6\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkensightgoldbinaryreader}{}\section{vtk\-En\-Sight\-Gold\-Binary\-Reader}\label{vtkio_vtkensightgoldbinaryreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-En\-Sight\-Gold\-Binary\-Reader is a class to read En\-Sight Gold files into vtk. Because the different parts of the En\-Sight data can be of various data types, this reader produces multiple outputs, one per part in the input file. All variable information is being stored in field data. The descriptions listed in the case file are used as the array names in the field data. For complex vector variables, the description is appended with \-\_\-r (for the array of real values) and \-\_\-i (for the array if imaginary values). Complex scalar variables are stored as a single array with 2 components, real and imaginary, listed in that order.

To create an instance of class vtk\-En\-Sight\-Gold\-Binary\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkEnSightGoldBinaryReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-En\-Sight\-Gold\-Binary\-Reader 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\-En\-Sight\-Gold\-Binary\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-En\-Sight\-Gold\-Binary\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-En\-Sight\-Gold\-Binary\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkensightgoldreader}{}\section{vtk\-En\-Sight\-Gold\-Reader}\label{vtkio_vtkensightgoldreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-En\-Sight\-Gold\-Reader is a class to read En\-Sight Gold files into vtk. Because the different parts of the En\-Sight data can be of various data types, this reader produces multiple outputs, one per part in the input file. All variable information is being stored in field data. The descriptions listed in the case file are used as the array names in the field data. For complex vector variables, the description is appended with \-\_\-r (for the array of real values) and \-\_\-i (for the array if imaginary values). Complex scalar variables are stored as a single array with 2 components, real and imaginary, listed in that order.

To create an instance of class vtk\-En\-Sight\-Gold\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkEnSightGoldReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-En\-Sight\-Gold\-Reader 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\-En\-Sight\-Gold\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-En\-Sight\-Gold\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-En\-Sight\-Gold\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkfacetwriter}{}\section{vtk\-Facet\-Writer}\label{vtkio_vtkfacetwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Facet\-Writer creates an unstructured grid dataset. It reads A\-S\-C\-I\-I files stored in Facet format

The facet format looks like this\-: F\-A\-C\-E\-T F\-I\-L\-E ... nparts Part 1 name 0 npoints 0 0 p1x p1y p1z p2x p2y p2z ... 1 Part 1 name ncells npointspercell p1c1 p2c1 p3c1 ... pnc1 materialnum partnum p1c2 p2c2 p3c2 ... pnc2 materialnum partnum ...

To create an instance of class vtk\-Facet\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFacetWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Facet\-Writer 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\-Facet\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Facet\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Facet\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify file name of Facet datafile to read  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify file name of Facet datafile to read  
\item {\ttfamily obj.\-Write ()} -\/ Write data  
\end{DoxyItemize}\hypertarget{vtkio_vtkfluentreader}{}\section{vtk\-F\-L\-U\-E\-N\-T\-Reader}\label{vtkio_vtkfluentreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-F\-L\-U\-E\-N\-T\-Reader creates an unstructured grid dataset. It reads .cas and .dat files stored in F\-L\-U\-E\-N\-T native format.

.S\-E\-C\-T\-I\-O\-N Thanks Thanks to Brian W. Dotson \& Terry E. Jordan (Department of Energy, National Energy Technology Laboratory) \& Douglas Mc\-Corkle (Iowa State University) who developed this class. Please address all comments to Brian Dotson (\href{mailto:brian.dotson@netl.doe.gov}{\tt brian.\-dotson@netl.\-doe.\-gov}) \& Terry Jordan (\href{mailto:terry.jordan@sa.netl.doe.gov}{\tt terry.\-jordan@sa.\-netl.\-doe.\-gov}) \& Doug Mc\-Corkle (\href{mailto:mccdo@iastate.edu}{\tt mccdo@iastate.\-edu})

To create an instance of class vtk\-F\-L\-U\-E\-N\-T\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFLUENTReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-F\-L\-U\-E\-N\-T\-Reader 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\-F\-L\-U\-E\-N\-T\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-F\-L\-U\-E\-N\-T\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-F\-L\-U\-E\-N\-T\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify the file name of the Fluent case file to read.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify the file name of the Fluent case file to read.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Cells ()} -\/ Get the total number of cells. The number of cells is only valid after a successful read of the data file is performed. Initial value is 0.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Cell\-Arrays (void )} -\/ Get the number of cell arrays available in the input.  
\item {\ttfamily string = obj.\-Get\-Cell\-Array\-Name (int index)} -\/ Get the name of the cell array with the given index in the input.  
\item {\ttfamily int = obj.\-Get\-Cell\-Array\-Status (string name)} -\/ Get/\-Set whether the cell array with the given name is to be read.  
\item {\ttfamily obj.\-Set\-Cell\-Array\-Status (string name, int status)} -\/ Get/\-Set whether the cell array with the given name is to be read.  
\item {\ttfamily obj.\-Disable\-All\-Cell\-Arrays ()} -\/ Turn on/off all cell arrays.  
\item {\ttfamily obj.\-Enable\-All\-Cell\-Arrays ()} -\/ Turn on/off all cell arrays.  
\item {\ttfamily obj.\-Set\-Data\-Byte\-Order\-To\-Big\-Endian ()} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian. Not used when reading text files.  
\item {\ttfamily obj.\-Set\-Data\-Byte\-Order\-To\-Little\-Endian ()} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian. Not used when reading text files.  
\item {\ttfamily int = obj.\-Get\-Data\-Byte\-Order ()} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian. Not used when reading text files.  
\item {\ttfamily obj.\-Set\-Data\-Byte\-Order (int )} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian. Not used when reading text files.  
\item {\ttfamily string = obj.\-Get\-Data\-Byte\-Order\-As\-String ()} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian. Not used when reading text files.  
\end{DoxyItemize}\hypertarget{vtkio_vtkgambitreader}{}\section{vtk\-G\-A\-M\-B\-I\-T\-Reader}\label{vtkio_vtkgambitreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-G\-A\-M\-B\-I\-T\-Reader creates an unstructured grid dataset. It reads A\-S\-C\-I\-I files stored in G\-A\-M\-B\-I\-T neutral format, with optional data stored at the nodes or at the cells of the model. A cell-\/based fielddata stores the material id.

To create an instance of class vtk\-G\-A\-M\-B\-I\-T\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGAMBITReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-G\-A\-M\-B\-I\-T\-Reader 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\-G\-A\-M\-B\-I\-T\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-G\-A\-M\-B\-I\-T\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-G\-A\-M\-B\-I\-T\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify the file name of the G\-A\-M\-B\-I\-T data file to read.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify the file name of the G\-A\-M\-B\-I\-T data file to read.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Cells ()} -\/ Get the total number of cells. The number of cells is only valid after a successful read of the data file is performed.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Nodes ()} -\/ Get the total number of nodes. The number of nodes is only valid after a successful read of the data file is performed.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Node\-Fields ()} -\/ Get the number of data components at the nodes and cells.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Cell\-Fields ()} -\/ Get the number of data components at the nodes and cells.  
\end{DoxyItemize}\hypertarget{vtkio_vtkgaussiancubereader}{}\section{vtk\-Gaussian\-Cube\-Reader}\label{vtkio_vtkgaussiancubereader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Gaussian\-Cube\-Reader is a source object that reads A\-S\-C\-I\-I files following the description in \href{http://www.gaussian.com/00000430.htm}{\tt http\-://www.\-gaussian.\-com/00000430.\-htm} The File\-Name must be specified.

.S\-E\-C\-T\-I\-O\-N Thanks Dr. Jean M. Favre who developed and contributed this class.

To create an instance of class vtk\-Gaussian\-Cube\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGaussianCubeReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Gaussian\-Cube\-Reader 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\-Cube\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Gaussian\-Cube\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Gaussian\-Cube\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Transform = obj.\-Get\-Transform ()}  
\item {\ttfamily obj.\-Set\-File\-Name (string )}  
\item {\ttfamily string = obj.\-Get\-File\-Name ()}  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Grid\-Output ()}  
\end{DoxyItemize}\hypertarget{vtkio_vtkgenericdataobjectreader}{}\section{vtk\-Generic\-Data\-Object\-Reader}\label{vtkio_vtkgenericdataobjectreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Generic\-Data\-Object\-Reader is a class that provides instance variables and methods to read any type of data object in Visualization Toolkit (vtk) format. The output type of this class will vary depending upon the type of data file. Convenience methods are provided to return the data as a particular type. (See text for format description details). The superclass of this class, vtk\-Data\-Reader, provides many methods for controlling the reading of the data file, see vtk\-Data\-Reader for more information.

To create an instance of class vtk\-Generic\-Data\-Object\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGenericDataObjectReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Generic\-Data\-Object\-Reader 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\-Generic\-Data\-Object\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Generic\-Data\-Object\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Generic\-Data\-Object\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Output ()} -\/ Get the output of this filter  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Output (int idx)} -\/ Get the output of this filter  
\item {\ttfamily vtk\-Graph = obj.\-Get\-Graph\-Output ()} -\/ Get the output as various concrete types. This method is typically used when you know exactly what type of data is being read. Otherwise, use the general Get\-Output() method. If the wrong type is used N\-U\-L\-L is returned. (You must also set the filename of the object prior to getting the output.)  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Poly\-Data\-Output ()} -\/ Get the output as various concrete types. This method is typically used when you know exactly what type of data is being read. Otherwise, use the general Get\-Output() method. If the wrong type is used N\-U\-L\-L is returned. (You must also set the filename of the object prior to getting the output.)  
\item {\ttfamily vtk\-Rectilinear\-Grid = obj.\-Get\-Rectilinear\-Grid\-Output ()} -\/ Get the output as various concrete types. This method is typically used when you know exactly what type of data is being read. Otherwise, use the general Get\-Output() method. If the wrong type is used N\-U\-L\-L is returned. (You must also set the filename of the object prior to getting the output.)  
\item {\ttfamily vtk\-Structured\-Grid = obj.\-Get\-Structured\-Grid\-Output ()} -\/ Get the output as various concrete types. This method is typically used when you know exactly what type of data is being read. Otherwise, use the general Get\-Output() method. If the wrong type is used N\-U\-L\-L is returned. (You must also set the filename of the object prior to getting the output.)  
\item {\ttfamily vtk\-Structured\-Points = obj.\-Get\-Structured\-Points\-Output ()} -\/ Get the output as various concrete types. This method is typically used when you know exactly what type of data is being read. Otherwise, use the general Get\-Output() method. If the wrong type is used N\-U\-L\-L is returned. (You must also set the filename of the object prior to getting the output.)  
\item {\ttfamily vtk\-Table = obj.\-Get\-Table\-Output ()} -\/ Get the output as various concrete types. This method is typically used when you know exactly what type of data is being read. Otherwise, use the general Get\-Output() method. If the wrong type is used N\-U\-L\-L is returned. (You must also set the filename of the object prior to getting the output.)  
\item {\ttfamily vtk\-Tree = obj.\-Get\-Tree\-Output ()} -\/ Get the output as various concrete types. This method is typically used when you know exactly what type of data is being read. Otherwise, use the general Get\-Output() method. If the wrong type is used N\-U\-L\-L is returned. (You must also set the filename of the object prior to getting the output.)  
\item {\ttfamily vtk\-Unstructured\-Grid = obj.\-Get\-Unstructured\-Grid\-Output ()} -\/ Get the output as various concrete types. This method is typically used when you know exactly what type of data is being read. Otherwise, use the general Get\-Output() method. If the wrong type is used N\-U\-L\-L is returned. (You must also set the filename of the object prior to getting the output.)  
\item {\ttfamily int = obj.\-Read\-Output\-Type ()} -\/ This method can be used to find out the type of output expected without needing to read the whole file.  
\end{DoxyItemize}\hypertarget{vtkio_vtkgenericdataobjectwriter}{}\section{vtk\-Generic\-Data\-Object\-Writer}\label{vtkio_vtkgenericdataobjectwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Generic\-Data\-Object\-Writer is a concrete class that writes data objects to disk. The input to this object is any subclass of vtk\-Data\-Object.

To create an instance of class vtk\-Generic\-Data\-Object\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGenericDataObjectWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Generic\-Data\-Object\-Writer 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\-Generic\-Data\-Object\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Generic\-Data\-Object\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Generic\-Data\-Object\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkgenericensightreader}{}\section{vtk\-Generic\-En\-Sight\-Reader}\label{vtkio_vtkgenericensightreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The class vtk\-Generic\-En\-Sight\-Reader allows the user to read an En\-Sight data set without a priori knowledge of what type of En\-Sight data set it is.

To create an instance of class vtk\-Generic\-En\-Sight\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGenericEnSightReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Generic\-En\-Sight\-Reader 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\-Generic\-En\-Sight\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Generic\-En\-Sight\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Generic\-En\-Sight\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Case\-File\-Name (string file\-Name)} -\/ Set/\-Get the Case file name.  
\item {\ttfamily string = obj.\-Get\-Case\-File\-Name ()} -\/ Set/\-Get the Case file name.  
\item {\ttfamily obj.\-Set\-File\-Path (string )} -\/ Set/\-Get the file path.  
\item {\ttfamily string = obj.\-Get\-File\-Path ()} -\/ Set/\-Get the file path.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Variables ()} -\/ Get the number of variables listed in the case file.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Complex\-Variables ()} -\/ Get the number of variables listed in the case file.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Variables (int type)} -\/ Get the number of variables of a particular type.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Scalars\-Per\-Node ()} -\/ Get the number of variables of a particular type.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Vectors\-Per\-Node ()} -\/ Get the number of variables of a particular type.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Tensors\-Symm\-Per\-Node ()} -\/ Get the number of variables of a particular type.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Scalars\-Per\-Element ()} -\/ Get the number of variables of a particular type.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Vectors\-Per\-Element ()} -\/ Get the number of variables of a particular type.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Tensors\-Symm\-Per\-Element ()} -\/ Get the number of variables of a particular type.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Scalars\-Per\-Measured\-Node ()} -\/ Get the number of variables of a particular type.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Vectors\-Per\-Measured\-Node ()} -\/ Get the number of variables of a particular type.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Complex\-Scalars\-Per\-Node ()} -\/ Get the number of variables of a particular type.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Complex\-Vectors\-Per\-Node ()} -\/ Get the number of variables of a particular type.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Complex\-Scalars\-Per\-Element ()} -\/ Get the number of variables of a particular type.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Complex\-Vectors\-Per\-Element ()} -\/ Get the number of variables of a particular type.  
\item {\ttfamily string = obj.\-Get\-Description (int n)} -\/ Get the nth description for a non-\/complex variable.  
\item {\ttfamily string = obj.\-Get\-Complex\-Description (int n)} -\/ Get the nth description for a complex variable.  
\item {\ttfamily string = obj.\-Get\-Description (int n, int type)} -\/ Get the nth description of a particular variable type. Returns N\-U\-L\-L if no variable of this type exists in this data set. S\-C\-A\-L\-A\-R\-\_\-\-P\-E\-R\-\_\-\-N\-O\-D\-E = 0; V\-E\-C\-T\-O\-R\-\_\-\-P\-E\-R\-\_\-\-N\-O\-D\-E = 1; T\-E\-N\-S\-O\-R\-\_\-\-S\-Y\-M\-M\-\_\-\-P\-E\-R\-\_\-\-N\-O\-D\-E = 2; S\-C\-A\-L\-A\-R\-\_\-\-P\-E\-R\-\_\-\-E\-L\-E\-M\-E\-N\-T = 3; V\-E\-C\-T\-O\-R\-\_\-\-P\-E\-R\-\_\-\-E\-L\-E\-M\-E\-N\-T = 4; T\-E\-N\-S\-O\-R\-\_\-\-S\-Y\-M\-M\-\_\-\-P\-E\-R\-\_\-\-E\-L\-E\-M\-E\-N\-T = 5; S\-C\-A\-L\-A\-R\-\_\-\-P\-E\-R\-\_\-\-M\-E\-A\-S\-U\-R\-E\-D\-\_\-\-N\-O\-D\-E = 6; V\-E\-C\-T\-O\-R\-\_\-\-P\-E\-R\-\_\-\-M\-E\-A\-S\-U\-R\-E\-D\-\_\-\-N\-O\-D\-E = 7; C\-O\-M\-P\-L\-E\-X\-\_\-\-S\-C\-A\-L\-A\-R\-\_\-\-P\-E\-R\-\_\-\-N\-O\-D\-E = 8; C\-O\-M\-P\-L\-E\-X\-\_\-\-V\-E\-C\-T\-O\-R\-\_\-\-P\-E\-R\-\_\-\-N\-O\-D\-E 9; C\-O\-M\-P\-L\-E\-X\-\_\-\-S\-C\-A\-L\-A\-R\-\_\-\-P\-E\-R\-\_\-\-E\-L\-E\-M\-E\-N\-T = 10; C\-O\-M\-P\-L\-E\-X\-\_\-\-V\-E\-C\-T\-O\-R\-\_\-\-P\-E\-R\-\_\-\-E\-L\-E\-M\-E\-N\-T = 11  
\item {\ttfamily int = obj.\-Get\-Variable\-Type (int n)} -\/ Get the variable type of variable n.  
\item {\ttfamily int = obj.\-Get\-Complex\-Variable\-Type (int n)} -\/ Get the variable type of variable n.  
\item {\ttfamily obj.\-Set\-Time\-Value (float value)} -\/ Set/\-Get the time value at which to get the value.  
\item {\ttfamily float = obj.\-Get\-Time\-Value ()} -\/ Set/\-Get the time value at which to get the value.  
\item {\ttfamily float = obj.\-Get\-Minimum\-Time\-Value ()} -\/ Get the minimum or maximum time value for this data set.  
\item {\ttfamily float = obj.\-Get\-Maximum\-Time\-Value ()} -\/ Get the minimum or maximum time value for this data set.  
\item {\ttfamily vtk\-Data\-Array\-Collection = obj.\-Get\-Time\-Sets ()} -\/ Get the time values per time set  
\item {\ttfamily int = obj.\-Determine\-En\-Sight\-Version (int quiet)} -\/ Reads the F\-O\-R\-M\-A\-T part of the case file to determine whether this is an En\-Sight6 or En\-Sight\-Gold data set. Returns an identifier listed in the File\-Types enum or -\/1 if an error occurred or the file could not be indentified as any En\-Sight type.  
\item {\ttfamily obj.\-Read\-All\-Variables\-On ()} -\/ Set/get the flag for whether to read all the variables  
\item {\ttfamily obj.\-Read\-All\-Variables\-Off ()} -\/ Set/get the flag for whether to read all the variables  
\item {\ttfamily obj.\-Set\-Read\-All\-Variables (int )} -\/ Set/get the flag for whether to read all the variables  
\item {\ttfamily int = obj.\-Get\-Read\-All\-Variables ()} -\/ Set/get the flag for whether to read all the variables  
\item {\ttfamily vtk\-Data\-Array\-Selection = obj.\-Get\-Point\-Data\-Array\-Selection ()} -\/ Get the data array selection tables used to configure which data arrays are loaded by the reader.  
\item {\ttfamily vtk\-Data\-Array\-Selection = obj.\-Get\-Cell\-Data\-Array\-Selection ()} -\/ Get the data array selection tables used to configure which data arrays are loaded by the reader.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Point\-Arrays ()} -\/ Get the number of point or cell arrays available in the input.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Cell\-Arrays ()} -\/ Get the number of point or cell arrays available in the input.  
\item {\ttfamily string = obj.\-Get\-Point\-Array\-Name (int index)} -\/ Get the name of the point or cell array with the given index in the input.  
\item {\ttfamily string = obj.\-Get\-Cell\-Array\-Name (int index)} -\/ Get the name of the point or cell array with the given index in the input.  
\item {\ttfamily int = obj.\-Get\-Point\-Array\-Status (string name)} -\/ Get/\-Set whether the point or cell array with the given name is to be read.  
\item {\ttfamily int = obj.\-Get\-Cell\-Array\-Status (string name)} -\/ Get/\-Set whether the point or cell array with the given name is to be read.  
\item {\ttfamily obj.\-Set\-Point\-Array\-Status (string name, int status)} -\/ Get/\-Set whether the point or cell array with the given name is to be read.  
\item {\ttfamily obj.\-Set\-Cell\-Array\-Status (string name, int status)} -\/ Get/\-Set whether the point or cell array with the given name is to be read.  
\item {\ttfamily obj.\-Set\-Byte\-Order\-To\-Big\-Endian ()} -\/ Set the byte order of the file (remember, more Unix workstations write big endian whereas P\-Cs write little endian). Default is big endian (since most older P\-L\-O\-T3\-D files were written by workstations).  
\item {\ttfamily obj.\-Set\-Byte\-Order\-To\-Little\-Endian ()} -\/ Set the byte order of the file (remember, more Unix workstations write big endian whereas P\-Cs write little endian). Default is big endian (since most older P\-L\-O\-T3\-D files were written by workstations).  
\item {\ttfamily obj.\-Set\-Byte\-Order (int )} -\/ Set the byte order of the file (remember, more Unix workstations write big endian whereas P\-Cs write little endian). Default is big endian (since most older P\-L\-O\-T3\-D files were written by workstations).  
\item {\ttfamily int = obj.\-Get\-Byte\-Order ()} -\/ Set the byte order of the file (remember, more Unix workstations write big endian whereas P\-Cs write little endian). Default is big endian (since most older P\-L\-O\-T3\-D files were written by workstations).  
\item {\ttfamily string = obj.\-Get\-Byte\-Order\-As\-String ()} -\/ Set the byte order of the file (remember, more Unix workstations write big endian whereas P\-Cs write little endian). Default is big endian (since most older P\-L\-O\-T3\-D files were written by workstations).  
\item {\ttfamily string = obj.\-Get\-Geometry\-File\-Name ()} -\/ Get the Geometry file name. Made public to allow access from apps requiring detailed info about the Data contents  
\item {\ttfamily obj.\-Set\-Particle\-Coordinates\-By\-Index (int )} -\/ The Measured\-Geometry\-File should list particle coordinates from 0-\/$>$N-\/1. If a file is loaded where point Ids are listed from 1-\/\-N the Id to points reference will be wrong and the data will be generated incorrectly. Setting Particle\-Coordinates\-By\-Index to true will force all Id's to increment from 0-\/$>$N-\/1 (relative to their order in the file) and regardless of the actual Id of of the point. Warning, if the Points are listed in non sequential order then setting this flag will reorder them.  
\item {\ttfamily int = obj.\-Get\-Particle\-Coordinates\-By\-Index ()} -\/ The Measured\-Geometry\-File should list particle coordinates from 0-\/$>$N-\/1. If a file is loaded where point Ids are listed from 1-\/\-N the Id to points reference will be wrong and the data will be generated incorrectly. Setting Particle\-Coordinates\-By\-Index to true will force all Id's to increment from 0-\/$>$N-\/1 (relative to their order in the file) and regardless of the actual Id of of the point. Warning, if the Points are listed in non sequential order then setting this flag will reorder them.  
\item {\ttfamily obj.\-Particle\-Coordinates\-By\-Index\-On ()} -\/ The Measured\-Geometry\-File should list particle coordinates from 0-\/$>$N-\/1. If a file is loaded where point Ids are listed from 1-\/\-N the Id to points reference will be wrong and the data will be generated incorrectly. Setting Particle\-Coordinates\-By\-Index to true will force all Id's to increment from 0-\/$>$N-\/1 (relative to their order in the file) and regardless of the actual Id of of the point. Warning, if the Points are listed in non sequential order then setting this flag will reorder them.  
\item {\ttfamily obj.\-Particle\-Coordinates\-By\-Index\-Off ()} -\/ The Measured\-Geometry\-File should list particle coordinates from 0-\/$>$N-\/1. If a file is loaded where point Ids are listed from 1-\/\-N the Id to points reference will be wrong and the data will be generated incorrectly. Setting Particle\-Coordinates\-By\-Index to true will force all Id's to increment from 0-\/$>$N-\/1 (relative to their order in the file) and regardless of the actual Id of of the point. Warning, if the Points are listed in non sequential order then setting this flag will reorder them.  
\end{DoxyItemize}\hypertarget{vtkio_vtkgenericmoviewriter}{}\section{vtk\-Generic\-Movie\-Writer}\label{vtkio_vtkgenericmoviewriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Generic\-Movie\-Writer is the abstract base class for several movie writers. The input type is a vtk\-Image\-Data. The Start() method will open and create the file, the Write() method will output a frame to the file (i.\-e. the contents of the vtk\-Image\-Data), End() will finalize and close the file.

To create an instance of class vtk\-Generic\-Movie\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGenericMovieWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Generic\-Movie\-Writer 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\-Generic\-Movie\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Generic\-Movie\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Generic\-Movie\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Input (vtk\-Image\-Data input)} -\/ Set/\-Get the input object from the image pipeline.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Input ()} -\/ Set/\-Get the input object from the image pipeline.  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify file name of avi file.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify file name of avi file.  
\item {\ttfamily obj.\-Start ()} -\/ These methods start writing an Movie file, write a frame to the file and then end the writing process.  
\item {\ttfamily obj.\-Write ()} -\/ These methods start writing an Movie file, write a frame to the file and then end the writing process.  
\item {\ttfamily obj.\-End ()} -\/ These methods start writing an Movie file, write a frame to the file and then end the writing process.  
\item {\ttfamily int = obj.\-Get\-Error ()} -\/ Was there an error on the last write performed?  
\end{DoxyItemize}\hypertarget{vtkio_vtkgesignareader}{}\section{vtk\-G\-E\-Signa\-Reader}\label{vtkio_vtkgesignareader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-G\-E\-Signa\-Reader is a source object that reads some G\-E Signa ximg files It does support reading in pixel spacing, slice spacing and it computes an origin for the image in millimeters. It always produces greyscale unsigned short data and it supports reading in rectangular, packed, compressed, and packed\&compressed. It does not read in slice orientation, or position right now. To use it you just need to specify a filename or a file prefix and pattern.

To create an instance of class vtk\-G\-E\-Signa\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGESignaReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-G\-E\-Signa\-Reader 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\-G\-E\-Signa\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-G\-E\-Signa\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-G\-E\-Signa\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Can\-Read\-File (string fname)} -\/ Is the given file a G\-E\-Signa file?  
\item {\ttfamily string = obj.\-Get\-File\-Extensions ()} -\/ A descriptive name for this format  
\item {\ttfamily string = obj.\-Get\-Descriptive\-Name ()}  
\end{DoxyItemize}\hypertarget{vtkio_vtkglobfilenames}{}\section{vtk\-Glob\-File\-Names}\label{vtkio_vtkglobfilenames}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Glob\-File\-Names is a utility for finding files and directories that match a given wildcard pattern. Allowed wildcards are , ?, \mbox{[}...\mbox{]}, \mbox{[}!...\mbox{]}. The \char`\"{}$\ast$\char`\"{} wildcard matches any substring, the \char`\"{}?\char`\"{} matches any single character, the \mbox{[}...\mbox{]} matches any one of the enclosed characters, e.\-g. \mbox{[}abc\mbox{]} will match one of a, b, or c, while \mbox{[}0-\/9\mbox{]} will match any digit, and \mbox{[}!...\mbox{]} will match any single character except for the ones within the brackets. Special treatment is given to \char`\"{}/\char`\"{} (or \char`\"{}\textbackslash{}\char`\"{} on Windows) because these are path separators. These are never matched by a wildcard, they are only matched with another file separator.

To create an instance of class vtk\-Glob\-File\-Names, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGlobFileNames
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Glob\-File\-Names 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\-Glob\-File\-Names 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\-Glob\-File\-Names = obj.\-New\-Instance ()} -\/ Return the class name as a string.  
\item {\ttfamily vtk\-Glob\-File\-Names = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Return the class name as a string.  
\item {\ttfamily obj.\-Reset ()} -\/ Reset the glob by clearing the list of output filenames.  
\item {\ttfamily obj.\-Set\-Directory (string )} -\/ Set the directory in which to perform the glob. If this is not set, then the current directory will be used. Also, if you use a glob pattern that contains absolute path (one that starts with \char`\"{}/\char`\"{} or a drive letter) then that absolute path will be used and Directory will be ignored.  
\item {\ttfamily string = obj.\-Get\-Directory ()} -\/ Set the directory in which to perform the glob. If this is not set, then the current directory will be used. Also, if you use a glob pattern that contains absolute path (one that starts with \char`\"{}/\char`\"{} or a drive letter) then that absolute path will be used and Directory will be ignored.  
\item {\ttfamily int = obj.\-Add\-File\-Names (string pattern)} -\/ Search for all files that match the given expression, sort them, and add them to the output. This method can be called repeatedly to add files matching additional patterns. Returns 1 if successful, otherwise returns zero.  
\item {\ttfamily obj.\-Set\-Recurse (int )} -\/ Recurse into subdirectories.  
\item {\ttfamily obj.\-Recurse\-On ()} -\/ Recurse into subdirectories.  
\item {\ttfamily obj.\-Recurse\-Off ()} -\/ Recurse into subdirectories.  
\item {\ttfamily int = obj.\-Get\-Recurse ()} -\/ Recurse into subdirectories.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-File\-Names ()} -\/ Return the number of files found.  
\item {\ttfamily string = obj.\-Get\-Nth\-File\-Name (int index)} -\/ Return the file at the given index, the indexing is 0 based.  
\item {\ttfamily vtk\-String\-Array = obj.\-Get\-File\-Names ()} -\/ Get an array that contains all the file names.  
\end{DoxyItemize}\hypertarget{vtkio_vtkgraphreader}{}\section{vtk\-Graph\-Reader}\label{vtkio_vtkgraphreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Graph\-Reader is a source object that reads A\-S\-C\-I\-I or binary vtk\-Graph data files in vtk format. (see text for format details). The output of this reader is a single vtk\-Graph data object. The superclass of this class, vtk\-Data\-Reader, provides many methods for controlling the reading of the data file, see vtk\-Data\-Reader for more information.

To create an instance of class vtk\-Graph\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGraphReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Graph\-Reader 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\-Graph\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Graph\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Graph\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Graph = obj.\-Get\-Output ()} -\/ Get the output of this reader.  
\item {\ttfamily vtk\-Graph = obj.\-Get\-Output (int idx)} -\/ Get the output of this reader.  
\item {\ttfamily obj.\-Set\-Output (vtk\-Graph output)} -\/ Get the output of this reader.  
\end{DoxyItemize}\hypertarget{vtkio_vtkgraphwriter}{}\section{vtk\-Graph\-Writer}\label{vtkio_vtkgraphwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Graph\-Writer is a sink object that writes A\-S\-C\-I\-I or binary vtk\-Graph data files in vtk format. See text for format details.

To create an instance of class vtk\-Graph\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGraphWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Graph\-Writer 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\-Graph\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Graph\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Graph\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Graph = obj.\-Get\-Input ()} -\/ Get the input to this writer.  
\item {\ttfamily vtk\-Graph = obj.\-Get\-Input (int port)} -\/ Get the input to this writer.  
\end{DoxyItemize}\hypertarget{vtkio_vtkimagereader}{}\section{vtk\-Image\-Reader}\label{vtkio_vtkimagereader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Reader provides methods needed to read a region from a file. It supports both transforms and masks on the input data, but as a result is more complicated and slower than its parent class vtk\-Image\-Reader2.

To create an instance of class vtk\-Image\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Reader 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\-Image\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Data\-V\-O\-I (int , int , int , int , int , int )} -\/ Set/get the data V\-O\-I. You can limit the reader to only read a subset of the data.  
\item {\ttfamily obj.\-Set\-Data\-V\-O\-I (int a\mbox{[}6\mbox{]})} -\/ Set/get the data V\-O\-I. You can limit the reader to only read a subset of the data.  
\item {\ttfamily int = obj. Get\-Data\-V\-O\-I ()} -\/ Set/get the data V\-O\-I. You can limit the reader to only read a subset of the data.  
\item {\ttfamily vtk\-Type\-U\-Int64 = obj.\-Get\-Data\-Mask ()} -\/ Set/\-Get the Data mask. The data mask is a simply integer whose bits are treated as a mask to the bits read from disk. That is, the data mask is bitwise-\/and'ed to the numbers read from disk. This ivar is stored as 64 bits, the largest mask you will need. The mask will be truncated to the data size required to be read (using the least significant bits).  
\item {\ttfamily obj.\-Set\-Data\-Mask (vtk\-Type\-U\-Int64 )} -\/ Set/\-Get the Data mask. The data mask is a simply integer whose bits are treated as a mask to the bits read from disk. That is, the data mask is bitwise-\/and'ed to the numbers read from disk. This ivar is stored as 64 bits, the largest mask you will need. The mask will be truncated to the data size required to be read (using the least significant bits).  
\item {\ttfamily obj.\-Set\-Transform (vtk\-Transform )} -\/ Set/\-Get transformation matrix to transform the data from slice space into world space. This matrix must be a permutation matrix. To qualify, the sums of the rows must be + or -\/ 1.  
\item {\ttfamily vtk\-Transform = obj.\-Get\-Transform ()} -\/ Set/\-Get transformation matrix to transform the data from slice space into world space. This matrix must be a permutation matrix. To qualify, the sums of the rows must be + or -\/ 1.  
\item {\ttfamily obj.\-Compute\-Inverse\-Transformed\-Extent (int in\-Extent\mbox{[}6\mbox{]}, int out\-Extent\mbox{[}6\mbox{]})}  
\item {\ttfamily int = obj.\-Open\-And\-Seek\-File (int extent\mbox{[}6\mbox{]}, int slice)}  
\item {\ttfamily obj.\-Set\-Scalar\-Array\-Name (string )} -\/ Set/get the scalar array name for this data set.  
\item {\ttfamily string = obj.\-Get\-Scalar\-Array\-Name ()} -\/ Set/get the scalar array name for this data set.  
\end{DoxyItemize}\hypertarget{vtkio_vtkimagereader2}{}\section{vtk\-Image\-Reader2}\label{vtkio_vtkimagereader2}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Reader2 is the parent class for vtk\-Image\-Reader. It is a good super class for streaming readers that do not require a mask or transform on the data. vtk\-Image\-Reader was implemented before vtk\-Image\-Reader2, vtk\-Image\-Reader2 is intended to have a simpler interface.

To create an instance of class vtk\-Image\-Reader2, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageReader2
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Reader2 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\-Image\-Reader2 class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Reader2 = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Reader2 = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify file name for the image file. If the data is stored in multiple files, then use Set\-File\-Names or Set\-File\-Prefix instead.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify file name for the image file. If the data is stored in multiple files, then use Set\-File\-Names or Set\-File\-Prefix instead.  
\item {\ttfamily obj.\-Set\-File\-Names (vtk\-String\-Array )} -\/ Specify a list of file names. Each file must be a single slice, and each slice must be of the same size. The files must be in the correct order. Use Set\-File\-Name when reading a volume (multiple slice), since Data\-Extent will be modified after a Set\-File\-Names call.  
\item {\ttfamily vtk\-String\-Array = obj.\-Get\-File\-Names ()} -\/ Specify a list of file names. Each file must be a single slice, and each slice must be of the same size. The files must be in the correct order. Use Set\-File\-Name when reading a volume (multiple slice), since Data\-Extent will be modified after a Set\-File\-Names call.  
\item {\ttfamily obj.\-Set\-File\-Prefix (string )} -\/ Specify file prefix for the image file or files. This can be used in place of Set\-File\-Name or Set\-File\-Names if the filenames follow a specific naming pattern, but you must explicitly set the Data\-Extent so that the reader will know what range of slices to load.  
\item {\ttfamily string = obj.\-Get\-File\-Prefix ()} -\/ Specify file prefix for the image file or files. This can be used in place of Set\-File\-Name or Set\-File\-Names if the filenames follow a specific naming pattern, but you must explicitly set the Data\-Extent so that the reader will know what range of slices to load.  
\item {\ttfamily obj.\-Set\-File\-Pattern (string )} -\/ The sprintf-\/style format string used to build filename from File\-Prefix and slice number.  
\item {\ttfamily string = obj.\-Get\-File\-Pattern ()} -\/ The sprintf-\/style format string used to build filename from File\-Prefix and slice number.  
\item {\ttfamily obj.\-Set\-Data\-Scalar\-Type (int type)} -\/ Set the data type of pixels in the file. If you want the output scalar type to have a different value, set it after this method is called.  
\item {\ttfamily obj.\-Set\-Data\-Scalar\-Type\-To\-Float ()} -\/ Set the data type of pixels in the file. If you want the output scalar type to have a different value, set it after this method is called.  
\item {\ttfamily obj.\-Set\-Data\-Scalar\-Type\-To\-Double ()} -\/ Set the data type of pixels in the file. If you want the output scalar type to have a different value, set it after this method is called.  
\item {\ttfamily obj.\-Set\-Data\-Scalar\-Type\-To\-Int ()} -\/ Set the data type of pixels in the file. If you want the output scalar type to have a different value, set it after this method is called.  
\item {\ttfamily obj.\-Set\-Data\-Scalar\-Type\-To\-Unsigned\-Int ()} -\/ Set the data type of pixels in the file. If you want the output scalar type to have a different value, set it after this method is called.  
\item {\ttfamily obj.\-Set\-Data\-Scalar\-Type\-To\-Short ()} -\/ Set the data type of pixels in the file. If you want the output scalar type to have a different value, set it after this method is called.  
\item {\ttfamily obj.\-Set\-Data\-Scalar\-Type\-To\-Unsigned\-Short ()} -\/ Set the data type of pixels in the file. If you want the output scalar type to have a different value, set it after this method is called.  
\item {\ttfamily obj.\-Set\-Data\-Scalar\-Type\-To\-Char ()} -\/ Set the data type of pixels in the file. If you want the output scalar type to have a different value, set it after this method is called.  
\item {\ttfamily obj.\-Set\-Data\-Scalar\-Type\-To\-Signed\-Char ()} -\/ Set the data type of pixels in the file. If you want the output scalar type to have a different value, set it after this method is called.  
\item {\ttfamily obj.\-Set\-Data\-Scalar\-Type\-To\-Unsigned\-Char ()} -\/ Get the file format. Pixels are this type in the file.  
\item {\ttfamily int = obj.\-Get\-Data\-Scalar\-Type ()} -\/ Get the file format. Pixels are this type in the file.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Scalar\-Components (int )} -\/ Set/\-Get the number of scalar components  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Scalar\-Components ()} -\/ Set/\-Get the number of scalar components  
\item {\ttfamily obj.\-Set\-Data\-Extent (int , int , int , int , int , int )} -\/ Get/\-Set the extent of the data on disk.  
\item {\ttfamily obj.\-Set\-Data\-Extent (int a\mbox{[}6\mbox{]})} -\/ Get/\-Set the extent of the data on disk.  
\item {\ttfamily int = obj. Get\-Data\-Extent ()} -\/ Get/\-Set the extent of the data on disk.  
\item {\ttfamily obj.\-Set\-File\-Dimensionality (int )} -\/ The number of dimensions stored in a file. This defaults to two.  
\item {\ttfamily int = obj.\-Get\-File\-Dimensionality ()} -\/ Set/\-Get the spacing of the data in the file.  
\item {\ttfamily obj.\-Set\-Data\-Spacing (double , double , double )} -\/ Set/\-Get the spacing of the data in the file.  
\item {\ttfamily obj.\-Set\-Data\-Spacing (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the spacing of the data in the file.  
\item {\ttfamily double = obj. Get\-Data\-Spacing ()} -\/ Set/\-Get the spacing of the data in the file.  
\item {\ttfamily obj.\-Set\-Data\-Origin (double , double , double )} -\/ Set/\-Get the origin of the data (location of first pixel in the file).  
\item {\ttfamily obj.\-Set\-Data\-Origin (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the origin of the data (location of first pixel in the file).  
\item {\ttfamily double = obj. Get\-Data\-Origin ()} -\/ Set/\-Get the origin of the data (location of first pixel in the file).  
\item {\ttfamily long = obj.\-Get\-Header\-Size ()} -\/ Get the size of the header computed by this object.  
\item {\ttfamily long = obj.\-Get\-Header\-Size (long slice)} -\/ Get the size of the header computed by this object.  
\item {\ttfamily obj.\-Set\-Header\-Size (long size)} -\/ If there is a tail on the file, you want to explicitly set the header size.  
\item {\ttfamily obj.\-Set\-Data\-Byte\-Order\-To\-Big\-Endian ()} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian.  
\item {\ttfamily obj.\-Set\-Data\-Byte\-Order\-To\-Little\-Endian ()} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian.  
\item {\ttfamily int = obj.\-Get\-Data\-Byte\-Order ()} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian.  
\item {\ttfamily obj.\-Set\-Data\-Byte\-Order (int )} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian.  
\item {\ttfamily string = obj.\-Get\-Data\-Byte\-Order\-As\-String ()} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian.  
\item {\ttfamily obj.\-Set\-File\-Name\-Slice\-Offset (int )} -\/ When reading files which start at an unusual index, this can be added to the slice number when generating the file name (default = 0)  
\item {\ttfamily int = obj.\-Get\-File\-Name\-Slice\-Offset ()} -\/ When reading files which start at an unusual index, this can be added to the slice number when generating the file name (default = 0)  
\item {\ttfamily obj.\-Set\-File\-Name\-Slice\-Spacing (int )} -\/ When reading files which have regular, but non contiguous slices (eg filename.\-1,filename.\-3,filename.\-5) a spacing can be specified to skip missing files (default = 1)  
\item {\ttfamily int = obj.\-Get\-File\-Name\-Slice\-Spacing ()} -\/ When reading files which have regular, but non contiguous slices (eg filename.\-1,filename.\-3,filename.\-5) a spacing can be specified to skip missing files (default = 1)  
\item {\ttfamily obj.\-Set\-Swap\-Bytes (int )} -\/ Set/\-Get the byte swapping to explicitly swap the bytes of a file.  
\item {\ttfamily int = obj.\-Get\-Swap\-Bytes ()} -\/ Set/\-Get the byte swapping to explicitly swap the bytes of a file.  
\item {\ttfamily obj.\-Swap\-Bytes\-On ()} -\/ Set/\-Get the byte swapping to explicitly swap the bytes of a file.  
\item {\ttfamily obj.\-Swap\-Bytes\-Off ()} -\/ Set/\-Get the byte swapping to explicitly swap the bytes of a file.  
\item {\ttfamily int = obj.\-Open\-File ()}  
\item {\ttfamily obj.\-Seek\-File (int i, int j, int k)}  
\item {\ttfamily obj.\-File\-Lower\-Left\-On ()} -\/ Set/\-Get whether the data comes from the file starting in the lower left corner or upper left corner.  
\item {\ttfamily obj.\-File\-Lower\-Left\-Off ()} -\/ Set/\-Get whether the data comes from the file starting in the lower left corner or upper left corner.  
\item {\ttfamily int = obj.\-Get\-File\-Lower\-Left ()} -\/ Set/\-Get whether the data comes from the file starting in the lower left corner or upper left corner.  
\item {\ttfamily obj.\-Set\-File\-Lower\-Left (int )} -\/ Set/\-Get whether the data comes from the file starting in the lower left corner or upper left corner.  
\item {\ttfamily obj.\-Compute\-Internal\-File\-Name (int slice)} -\/ Set/\-Get the internal file name  
\item {\ttfamily string = obj.\-Get\-Internal\-File\-Name ()} -\/ Set/\-Get the internal file name  
\item {\ttfamily int = obj.\-Can\-Read\-File (string )} -\/ Get the file extensions for this format. Returns a string with a space separated list of extensions in the format .extension  
\item {\ttfamily string = obj.\-Get\-File\-Extensions ()} -\/ Return a descriptive name for the file format that might be useful in a G\-U\-I.  
\item {\ttfamily string = obj.\-Get\-Descriptive\-Name ()} -\/ Return a descriptive name for the file format that might be useful in a G\-U\-I.  
\end{DoxyItemize}\hypertarget{vtkio_vtkimagereader2collection}{}\section{vtk\-Image\-Reader2\-Collection}\label{vtkio_vtkimagereader2collection}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Reader2\-Collection is an object that creates and manipulates lists of objects of type vtk\-Image\-Reader2 and its subclasses.

To create an instance of class vtk\-Image\-Reader2\-Collection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageReader2Collection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Reader2\-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\-Image\-Reader2\-Collection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Reader2\-Collection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Reader2\-Collection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Item (vtk\-Image\-Reader2 )} -\/ Add an image reader to the list.  
\item {\ttfamily vtk\-Image\-Reader2 = obj.\-Get\-Next\-Item ()} -\/ Get the next image reader in the list.  
\end{DoxyItemize}\hypertarget{vtkio_vtkimagereader2factory}{}\section{vtk\-Image\-Reader2\-Factory}\label{vtkio_vtkimagereader2factory}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Reader2\-Factory\-: This class is used to create a vtk\-Image\-Reader2 object given a path name to a file. It calls Can\-Read\-File on all available readers until one of them returns true. The available reader list comes from three places. In the Initialize\-Readers function of this class, built-\/in V\-T\-K classes are added to the list, users can call Register\-Reader, or users can create a vtk\-Object\-Factory that has Create\-Object method that returns a new vtk\-Image\-Reader2 sub class when given the string \char`\"{}vtk\-Image\-Reader\-Object\char`\"{}. This way applications can be extended with new readers via a plugin dll or by calling Register\-Reader. Of course all of the readers that are part of the vtk release are made automatically available.

To create an instance of class vtk\-Image\-Reader2\-Factory, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageReader2Factory
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Reader2\-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\-Image\-Reader2\-Factory class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Reader2\-Factory = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Reader2\-Factory = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkimagewriter}{}\section{vtk\-Image\-Writer}\label{vtkio_vtkimagewriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Writer writes images to files with any data type. The data type of the file is the same scalar type as the input. The dimensionality determines whether the data will be written in one or multiple files. This class is used as the superclass of most image writing classes such as vtk\-B\-M\-P\-Writer etc. It supports streaming.

To create an instance of class vtk\-Image\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Writer 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\-Image\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify file name for the image file. You should specify either a File\-Name or a File\-Prefix. Use File\-Prefix if the data is stored in multiple files.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify file name for the image file. You should specify either a File\-Name or a File\-Prefix. Use File\-Prefix if the data is stored in multiple files.  
\item {\ttfamily obj.\-Set\-File\-Prefix (string )} -\/ Specify file prefix for the image file(s).You should specify either a File\-Name or File\-Prefix. Use File\-Prefix if the data is stored in multiple files.  
\item {\ttfamily string = obj.\-Get\-File\-Prefix ()} -\/ Specify file prefix for the image file(s).You should specify either a File\-Name or File\-Prefix. Use File\-Prefix if the data is stored in multiple files.  
\item {\ttfamily obj.\-Set\-File\-Pattern (string )} -\/ The sprintf format used to build filename from File\-Prefix and number.  
\item {\ttfamily string = obj.\-Get\-File\-Pattern ()} -\/ The sprintf format used to build filename from File\-Prefix and number.  
\item {\ttfamily obj.\-Set\-File\-Dimensionality (int )} -\/ What dimension are the files to be written. Usually this is 2, or 3. If it is 2 and the input is a volume then the volume will be written as a series of 2d slices.  
\item {\ttfamily int = obj.\-Get\-File\-Dimensionality ()} -\/ What dimension are the files to be written. Usually this is 2, or 3. If it is 2 and the input is a volume then the volume will be written as a series of 2d slices.  
\item {\ttfamily obj.\-Write ()} -\/ The main interface which triggers the writer to start.  
\item {\ttfamily obj.\-Delete\-Files ()}  
\end{DoxyItemize}\hypertarget{vtkio_vtkinputstream}{}\section{vtk\-Input\-Stream}\label{vtkio_vtkinputstream}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Input\-Stream provides a V\-T\-K-\/style interface wrapping around a standard input stream. The access methods are virtual so that subclasses can transparently provide decoding of an encoded stream. Data lengths for Seek and Read calls refer to the length of the input data. The actual length in the stream may differ for subclasses that implement an encoding scheme.

To create an instance of class vtk\-Input\-Stream, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInputStream
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Input\-Stream 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\-Input\-Stream class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Input\-Stream = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Input\-Stream = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Start\-Reading ()} -\/ Called after the stream position has been set by the caller, but before any Seek or Read calls. The stream position should not be adjusted by the caller until after an End\-Reading call.  
\item {\ttfamily int = obj.\-Seek (long offset)} -\/ Seek to the given offset in the input data. Returns 1 for success, 0 for failure.  
\item {\ttfamily long = obj.\-Read (string data, long length)} -\/ Read input data of the given length. Returns amount actually read.  
\item {\ttfamily long = obj.\-Read (string data, long length)} -\/ Read input data of the given length. Returns amount actually read.  
\item {\ttfamily obj.\-End\-Reading ()} -\/ Called after all desired calls to Seek and Read have been made. After this call, the caller is free to change the position of the stream. Additional reads should not be done until after another call to Start\-Reading.  
\end{DoxyItemize}\hypertarget{vtkio_vtkivwriter}{}\section{vtk\-I\-V\-Writer}\label{vtkio_vtkivwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-I\-V\-Writer is a concrete subclass of vtk\-Writer that writes Open\-Inventor 2.\-0 files.

To create an instance of class vtk\-I\-V\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkIVWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-I\-V\-Writer 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\-I\-V\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-I\-V\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-I\-V\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkjpegreader}{}\section{vtk\-J\-P\-E\-G\-Reader}\label{vtkio_vtkjpegreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-J\-P\-E\-G\-Reader is a source object that reads J\-P\-E\-G files. It should be able to read most any J\-P\-E\-G file

To create an instance of class vtk\-J\-P\-E\-G\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkJPEGReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-J\-P\-E\-G\-Reader 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\-J\-P\-E\-G\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-J\-P\-E\-G\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-J\-P\-E\-G\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Can\-Read\-File (string fname)} -\/ Is the given file a J\-P\-E\-G file?  
\item {\ttfamily string = obj.\-Get\-File\-Extensions ()} -\/ Return a descriptive name for the file format that might be useful in a G\-U\-I.  
\item {\ttfamily string = obj.\-Get\-Descriptive\-Name ()} -\/ Return a descriptive name for the file format that might be useful in a G\-U\-I.  
\end{DoxyItemize}\hypertarget{vtkio_vtkjpegwriter}{}\section{vtk\-J\-P\-E\-G\-Writer}\label{vtkio_vtkjpegwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-J\-P\-E\-G\-Writer writes J\-P\-E\-G files. It supports 1 and 3 component data of unsigned char. It relies on the I\-J\-G's libjpeg. Thanks to I\-J\-G for supplying a public jpeg I\-O library.

To create an instance of class vtk\-J\-P\-E\-G\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkJPEGWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-J\-P\-E\-G\-Writer 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\-J\-P\-E\-G\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-J\-P\-E\-G\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-J\-P\-E\-G\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Write ()} -\/ The main interface which triggers the writer to start.  
\item {\ttfamily obj.\-Set\-Quality (int )} -\/ Compression quality. 0 = Low quality, 100 = High quality  
\item {\ttfamily int = obj.\-Get\-Quality\-Min\-Value ()} -\/ Compression quality. 0 = Low quality, 100 = High quality  
\item {\ttfamily int = obj.\-Get\-Quality\-Max\-Value ()} -\/ Compression quality. 0 = Low quality, 100 = High quality  
\item {\ttfamily int = obj.\-Get\-Quality ()} -\/ Compression quality. 0 = Low quality, 100 = High quality  
\item {\ttfamily obj.\-Set\-Progressive (int )} -\/ Progressive J\-P\-E\-G generation.  
\item {\ttfamily int = obj.\-Get\-Progressive ()} -\/ Progressive J\-P\-E\-G generation.  
\item {\ttfamily obj.\-Progressive\-On ()} -\/ Progressive J\-P\-E\-G generation.  
\item {\ttfamily obj.\-Progressive\-Off ()} -\/ Progressive J\-P\-E\-G generation.  
\item {\ttfamily obj.\-Set\-Write\-To\-Memory (int )} -\/ Write the image to memory (a vtk\-Unsigned\-Char\-Array)  
\item {\ttfamily int = obj.\-Get\-Write\-To\-Memory ()} -\/ Write the image to memory (a vtk\-Unsigned\-Char\-Array)  
\item {\ttfamily obj.\-Write\-To\-Memory\-On ()} -\/ Write the image to memory (a vtk\-Unsigned\-Char\-Array)  
\item {\ttfamily obj.\-Write\-To\-Memory\-Off ()} -\/ Write the image to memory (a vtk\-Unsigned\-Char\-Array)  
\item {\ttfamily obj.\-Set\-Result (vtk\-Unsigned\-Char\-Array )} -\/ When writing to memory this is the result, it will be N\-U\-L\-L until the data is written the first time  
\item {\ttfamily vtk\-Unsigned\-Char\-Array = obj.\-Get\-Result ()} -\/ When writing to memory this is the result, it will be N\-U\-L\-L until the data is written the first time  
\end{DoxyItemize}\hypertarget{vtkio_vtkmateriallibrary}{}\section{vtk\-Material\-Library}\label{vtkio_vtkmateriallibrary}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class provides the Material X\-M\-Ls. .S\-E\-C\-T\-I\-O\-N Thanks Shader support in V\-T\-K includes key contributions by Gary Templet at Sandia National Labs.

To create an instance of class vtk\-Material\-Library, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMaterialLibrary
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Material\-Library 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\-Material\-Library class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Material\-Library = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Material\-Library = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkmcubesreader}{}\section{vtk\-M\-Cubes\-Reader}\label{vtkio_vtkmcubesreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-M\-Cubes\-Reader is a source object that reads binary marching cubes files. (Marching cubes is an isosurfacing technique that generates many triangles.) The binary format is supported by W. Lorensen's marching cubes program (and the vtk\-Slice\-Cubes object). The format repeats point coordinates, so this object will merge the points with a vtk\-Locator object. You can choose to supply the vtk\-Locator or use the default.

To create an instance of class vtk\-M\-Cubes\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMCubesReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-M\-Cubes\-Reader 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\-M\-Cubes\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-M\-Cubes\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-M\-Cubes\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify file name of marching cubes file.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify file name of marching cubes file.  
\item {\ttfamily obj.\-Set\-Limits\-File\-Name (string )} -\/ Set / get the file name of the marching cubes limits file.  
\item {\ttfamily string = obj.\-Get\-Limits\-File\-Name ()} -\/ Set / get the file name of the marching cubes limits file.  
\item {\ttfamily obj.\-Set\-Header\-Size (int )} -\/ Specify a header size if one exists. The header is skipped and not used at this time.  
\item {\ttfamily int = obj.\-Get\-Header\-Size\-Min\-Value ()} -\/ Specify a header size if one exists. The header is skipped and not used at this time.  
\item {\ttfamily int = obj.\-Get\-Header\-Size\-Max\-Value ()} -\/ Specify a header size if one exists. The header is skipped and not used at this time.  
\item {\ttfamily int = obj.\-Get\-Header\-Size ()} -\/ Specify a header size if one exists. The header is skipped and not used at this time.  
\item {\ttfamily obj.\-Set\-Flip\-Normals (int )} -\/ Specify whether to flip normals in opposite direction. Flipping O\-N\-L\-Y changes the direction of the normal vector. Contrast this with flipping in vtk\-Poly\-Data\-Normals which flips both the normal and the cell point order.  
\item {\ttfamily int = obj.\-Get\-Flip\-Normals ()} -\/ Specify whether to flip normals in opposite direction. Flipping O\-N\-L\-Y changes the direction of the normal vector. Contrast this with flipping in vtk\-Poly\-Data\-Normals which flips both the normal and the cell point order.  
\item {\ttfamily obj.\-Flip\-Normals\-On ()} -\/ Specify whether to flip normals in opposite direction. Flipping O\-N\-L\-Y changes the direction of the normal vector. Contrast this with flipping in vtk\-Poly\-Data\-Normals which flips both the normal and the cell point order.  
\item {\ttfamily obj.\-Flip\-Normals\-Off ()} -\/ Specify whether to flip normals in opposite direction. Flipping O\-N\-L\-Y changes the direction of the normal vector. Contrast this with flipping in vtk\-Poly\-Data\-Normals which flips both the normal and the cell point order.  
\item {\ttfamily obj.\-Set\-Normals (int )} -\/ Specify whether to read normals.  
\item {\ttfamily int = obj.\-Get\-Normals ()} -\/ Specify whether to read normals.  
\item {\ttfamily obj.\-Normals\-On ()} -\/ Specify whether to read normals.  
\item {\ttfamily obj.\-Normals\-Off ()} -\/ Specify whether to read normals.  
\item {\ttfamily obj.\-Set\-Data\-Byte\-Order\-To\-Big\-Endian ()} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian.  
\item {\ttfamily obj.\-Set\-Data\-Byte\-Order\-To\-Little\-Endian ()} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian.  
\item {\ttfamily int = obj.\-Get\-Data\-Byte\-Order ()} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian.  
\item {\ttfamily obj.\-Set\-Data\-Byte\-Order (int )} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian.  
\item {\ttfamily string = obj.\-Get\-Data\-Byte\-Order\-As\-String ()} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian.  
\item {\ttfamily obj.\-Set\-Swap\-Bytes (int )} -\/ Turn on/off byte swapping.  
\item {\ttfamily int = obj.\-Get\-Swap\-Bytes ()} -\/ Turn on/off byte swapping.  
\item {\ttfamily obj.\-Swap\-Bytes\-On ()} -\/ Turn on/off byte swapping.  
\item {\ttfamily obj.\-Swap\-Bytes\-Off ()} -\/ Turn on/off byte swapping.  
\item {\ttfamily obj.\-Set\-Locator (vtk\-Incremental\-Point\-Locator locator)} -\/ Set / get a spatial locator for merging points. By default, an instance of vtk\-Merge\-Points is used.  
\item {\ttfamily vtk\-Incremental\-Point\-Locator = obj.\-Get\-Locator ()} -\/ Set / get a spatial locator for merging points. By default, an instance of vtk\-Merge\-Points is used.  
\item {\ttfamily obj.\-Create\-Default\-Locator ()} -\/ Create default locator. Used to create one when none is specified.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return the mtime also considering the locator.  
\end{DoxyItemize}\hypertarget{vtkio_vtkmcubeswriter}{}\section{vtk\-M\-Cubes\-Writer}\label{vtkio_vtkmcubeswriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-M\-Cubes\-Writer is a polydata writer that writes binary marching cubes files. (Marching cubes is an isosurfacing technique that generates many triangles.) The binary format is supported by W. Lorensen's marching cubes program (and the vtk\-Slice\-Cubes object). Each triangle is represented by three records, with each record consisting of six single precision floating point numbers representing the a triangle vertex coordinate and vertex normal.

To create an instance of class vtk\-M\-Cubes\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMCubesWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-M\-Cubes\-Writer 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\-M\-Cubes\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-M\-Cubes\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-M\-Cubes\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Limits\-File\-Name (string )} -\/ Set/get file name of marching cubes limits file.  
\item {\ttfamily string = obj.\-Get\-Limits\-File\-Name ()} -\/ Set/get file name of marching cubes limits file.  
\end{DoxyItemize}\hypertarget{vtkio_vtkmedicalimageproperties}{}\section{vtk\-Medical\-Image\-Properties}\label{vtkio_vtkmedicalimageproperties}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Medical\-Image\-Properties is a helper class that can be used by medical image readers and applications to encapsulate medical image/acquisition properties. Later on, this should probably be extended to add any user-\/defined property.

To create an instance of class vtk\-Medical\-Image\-Properties, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMedicalImageProperties
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Medical\-Image\-Properties 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\-Medical\-Image\-Properties class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Medical\-Image\-Properties = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Medical\-Image\-Properties = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Clear ()} -\/ Convenience method to reset all fields to an emptry string/value  
\item {\ttfamily obj.\-Set\-Patient\-Name (string )} -\/ Patient name For ex\-: D\-I\-C\-O\-M (0010,0010) = D\-O\-E,J\-O\-H\-N  
\item {\ttfamily string = obj.\-Get\-Patient\-Name ()} -\/ Patient name For ex\-: D\-I\-C\-O\-M (0010,0010) = D\-O\-E,J\-O\-H\-N  
\item {\ttfamily obj.\-Set\-Patient\-I\-D (string )} -\/ Patient I\-D For ex\-: D\-I\-C\-O\-M (0010,0020) = 1933197  
\item {\ttfamily string = obj.\-Get\-Patient\-I\-D ()} -\/ Patient I\-D For ex\-: D\-I\-C\-O\-M (0010,0020) = 1933197  
\item {\ttfamily obj.\-Set\-Patient\-Age (string )} -\/ Patient age Format\-: nnn\-D, nn\-W, nnn\-M or nnn\-Y (eventually nn\-D, nn\-W, nn\-Y) with D (day), M (month), W (week), Y (year) For ex\-: D\-I\-C\-O\-M (0010,1010) = 031\-Y  
\item {\ttfamily string = obj.\-Get\-Patient\-Age ()} -\/ Patient age Format\-: nnn\-D, nn\-W, nnn\-M or nnn\-Y (eventually nn\-D, nn\-W, nn\-Y) with D (day), M (month), W (week), Y (year) For ex\-: D\-I\-C\-O\-M (0010,1010) = 031\-Y  
\item {\ttfamily int = obj.\-Get\-Patient\-Age\-Year ()}  
\item {\ttfamily int = obj.\-Get\-Patient\-Age\-Month ()}  
\item {\ttfamily int = obj.\-Get\-Patient\-Age\-Week ()}  
\item {\ttfamily int = obj.\-Get\-Patient\-Age\-Day ()}  
\item {\ttfamily obj.\-Set\-Patient\-Sex (string )} -\/ Patient sex For ex\-: D\-I\-C\-O\-M (0010,0040) = M  
\item {\ttfamily string = obj.\-Get\-Patient\-Sex ()} -\/ Patient sex For ex\-: D\-I\-C\-O\-M (0010,0040) = M  
\item {\ttfamily obj.\-Set\-Patient\-Birth\-Date (string )} -\/ Patient birth date Format\-: yyyymmdd For ex\-: D\-I\-C\-O\-M (0010,0030) = 19680427  
\item {\ttfamily string = obj.\-Get\-Patient\-Birth\-Date ()} -\/ Patient birth date Format\-: yyyymmdd For ex\-: D\-I\-C\-O\-M (0010,0030) = 19680427  
\item {\ttfamily int = obj.\-Get\-Patient\-Birth\-Date\-Year ()}  
\item {\ttfamily int = obj.\-Get\-Patient\-Birth\-Date\-Month ()}  
\item {\ttfamily int = obj.\-Get\-Patient\-Birth\-Date\-Day ()}  
\item {\ttfamily obj.\-Set\-Study\-Date (string )} -\/ Study Date Format\-: yyyymmdd For ex\-: D\-I\-C\-O\-M (0008,0020) = 20030617  
\item {\ttfamily string = obj.\-Get\-Study\-Date ()} -\/ Study Date Format\-: yyyymmdd For ex\-: D\-I\-C\-O\-M (0008,0020) = 20030617  
\item {\ttfamily obj.\-Set\-Acquisition\-Date (string )} -\/ Acquisition Date Format\-: yyyymmdd For ex\-: D\-I\-C\-O\-M (0008,0022) = 20030617  
\item {\ttfamily string = obj.\-Get\-Acquisition\-Date ()} -\/ Acquisition Date Format\-: yyyymmdd For ex\-: D\-I\-C\-O\-M (0008,0022) = 20030617  
\item {\ttfamily int = obj.\-Get\-Acquisition\-Date\-Year ()}  
\item {\ttfamily int = obj.\-Get\-Acquisition\-Date\-Month ()}  
\item {\ttfamily int = obj.\-Get\-Acquisition\-Date\-Day ()}  
\item {\ttfamily obj.\-Set\-Study\-Time (string )} -\/ Study Time Format\-: hhmmss.\-frac (any trailing component(s) can be ommited) For ex\-: D\-I\-C\-O\-M (0008,0030) = 162552.\-0705 or 230012, or 0012  
\item {\ttfamily string = obj.\-Get\-Study\-Time ()} -\/ Study Time Format\-: hhmmss.\-frac (any trailing component(s) can be ommited) For ex\-: D\-I\-C\-O\-M (0008,0030) = 162552.\-0705 or 230012, or 0012  
\item {\ttfamily obj.\-Set\-Acquisition\-Time (string )} -\/ Acquisition time Format\-: hhmmss.\-frac (any trailing component(s) can be ommited) For ex\-: D\-I\-C\-O\-M (0008,0032) = 162552.\-0705 or 230012, or 0012  
\item {\ttfamily string = obj.\-Get\-Acquisition\-Time ()} -\/ Acquisition time Format\-: hhmmss.\-frac (any trailing component(s) can be ommited) For ex\-: D\-I\-C\-O\-M (0008,0032) = 162552.\-0705 or 230012, or 0012  
\item {\ttfamily obj.\-Set\-Image\-Date (string )} -\/ Image Date aka Content Date Format\-: yyyymmdd For ex\-: D\-I\-C\-O\-M (0008,0023) = 20030617  
\item {\ttfamily string = obj.\-Get\-Image\-Date ()} -\/ Image Date aka Content Date Format\-: yyyymmdd For ex\-: D\-I\-C\-O\-M (0008,0023) = 20030617  
\item {\ttfamily int = obj.\-Get\-Image\-Date\-Year ()}  
\item {\ttfamily int = obj.\-Get\-Image\-Date\-Month ()}  
\item {\ttfamily int = obj.\-Get\-Image\-Date\-Day ()}  
\item {\ttfamily obj.\-Set\-Image\-Time (string )} -\/ Image Time Format\-: hhmmss.\-frac (any trailing component(s) can be ommited) For ex\-: D\-I\-C\-O\-M (0008,0033) = 162552.\-0705 or 230012, or 0012  
\item {\ttfamily string = obj.\-Get\-Image\-Time ()} -\/ Image Time Format\-: hhmmss.\-frac (any trailing component(s) can be ommited) For ex\-: D\-I\-C\-O\-M (0008,0033) = 162552.\-0705 or 230012, or 0012  
\item {\ttfamily obj.\-Set\-Image\-Number (string )} -\/ Image number For ex\-: D\-I\-C\-O\-M (0020,0013) = 1  
\item {\ttfamily string = obj.\-Get\-Image\-Number ()} -\/ Image number For ex\-: D\-I\-C\-O\-M (0020,0013) = 1  
\item {\ttfamily obj.\-Set\-Series\-Number (string )} -\/ Series number For ex\-: D\-I\-C\-O\-M (0020,0011) = 902  
\item {\ttfamily string = obj.\-Get\-Series\-Number ()} -\/ Series number For ex\-: D\-I\-C\-O\-M (0020,0011) = 902  
\item {\ttfamily obj.\-Set\-Series\-Description (string )} -\/ Series Description User provided description of the Series For ex\-: D\-I\-C\-O\-M (0008,103e) = S\-C\-O\-U\-T  
\item {\ttfamily string = obj.\-Get\-Series\-Description ()} -\/ Series Description User provided description of the Series For ex\-: D\-I\-C\-O\-M (0008,103e) = S\-C\-O\-U\-T  
\item {\ttfamily obj.\-Set\-Study\-I\-D (string )} -\/ Study I\-D For ex\-: D\-I\-C\-O\-M (0020,0010) = 37481  
\item {\ttfamily string = obj.\-Get\-Study\-I\-D ()} -\/ Study I\-D For ex\-: D\-I\-C\-O\-M (0020,0010) = 37481  
\item {\ttfamily obj.\-Set\-Study\-Description (string )} -\/ Study description For ex\-: D\-I\-C\-O\-M (0008,1030) = B\-R\-A\-I\-N/\-C-\/\-S\-P/\-F\-A\-C\-I\-A\-L  
\item {\ttfamily string = obj.\-Get\-Study\-Description ()} -\/ Study description For ex\-: D\-I\-C\-O\-M (0008,1030) = B\-R\-A\-I\-N/\-C-\/\-S\-P/\-F\-A\-C\-I\-A\-L  
\item {\ttfamily obj.\-Set\-Modality (string )} -\/ Modality For ex\-: D\-I\-C\-O\-M (0008,0060)= C\-T  
\item {\ttfamily string = obj.\-Get\-Modality ()} -\/ Modality For ex\-: D\-I\-C\-O\-M (0008,0060)= C\-T  
\item {\ttfamily obj.\-Set\-Manufacturer (string )} -\/ Manufacturer For ex\-: D\-I\-C\-O\-M (0008,0070) = Siemens  
\item {\ttfamily string = obj.\-Get\-Manufacturer ()} -\/ Manufacturer For ex\-: D\-I\-C\-O\-M (0008,0070) = Siemens  
\item {\ttfamily obj.\-Set\-Manufacturer\-Model\-Name (string )} -\/ Manufacturer's Model Name For ex\-: D\-I\-C\-O\-M (0008,1090) = Light\-Speed Q\-X/i  
\item {\ttfamily string = obj.\-Get\-Manufacturer\-Model\-Name ()} -\/ Manufacturer's Model Name For ex\-: D\-I\-C\-O\-M (0008,1090) = Light\-Speed Q\-X/i  
\item {\ttfamily obj.\-Set\-Station\-Name (string )} -\/ Station Name For ex\-: D\-I\-C\-O\-M (0008,1010) = L\-S\-P\-D\-\_\-\-O\-C8  
\item {\ttfamily string = obj.\-Get\-Station\-Name ()} -\/ Station Name For ex\-: D\-I\-C\-O\-M (0008,1010) = L\-S\-P\-D\-\_\-\-O\-C8  
\item {\ttfamily obj.\-Set\-Institution\-Name (string )} -\/ Institution Name For ex\-: D\-I\-C\-O\-M (0008,0080) = Foo\-City Medical Center  
\item {\ttfamily string = obj.\-Get\-Institution\-Name ()} -\/ Institution Name For ex\-: D\-I\-C\-O\-M (0008,0080) = Foo\-City Medical Center  
\item {\ttfamily obj.\-Set\-Convolution\-Kernel (string )} -\/ Convolution Kernel (or algorithm used to reconstruct the data) For ex\-: D\-I\-C\-O\-M (0018,1210) = Bone  
\item {\ttfamily string = obj.\-Get\-Convolution\-Kernel ()} -\/ Convolution Kernel (or algorithm used to reconstruct the data) For ex\-: D\-I\-C\-O\-M (0018,1210) = Bone  
\item {\ttfamily obj.\-Set\-Slice\-Thickness (string )} -\/ Slice Thickness (Nominal reconstructed slice thickness, in mm) For ex\-: D\-I\-C\-O\-M (0018,0050) = 0.\-273438  
\item {\ttfamily string = obj.\-Get\-Slice\-Thickness ()} -\/ Slice Thickness (Nominal reconstructed slice thickness, in mm) For ex\-: D\-I\-C\-O\-M (0018,0050) = 0.\-273438  
\item {\ttfamily double = obj.\-Get\-Slice\-Thickness\-As\-Double ()} -\/ Slice Thickness (Nominal reconstructed slice thickness, in mm) For ex\-: D\-I\-C\-O\-M (0018,0050) = 0.\-273438  
\item {\ttfamily obj.\-Set\-K\-V\-P (string )} -\/ Peak kilo voltage output of the (x-\/ray) generator used For ex\-: D\-I\-C\-O\-M (0018,0060) = 120  
\item {\ttfamily string = obj.\-Get\-K\-V\-P ()} -\/ Peak kilo voltage output of the (x-\/ray) generator used For ex\-: D\-I\-C\-O\-M (0018,0060) = 120  
\item {\ttfamily obj.\-Set\-Gantry\-Tilt (string )} -\/ Gantry/\-Detector tilt (Nominal angle of tilt in degrees of the scanning gantry.) For ex\-: D\-I\-C\-O\-M (0018,1120) = 15  
\item {\ttfamily string = obj.\-Get\-Gantry\-Tilt ()} -\/ Gantry/\-Detector tilt (Nominal angle of tilt in degrees of the scanning gantry.) For ex\-: D\-I\-C\-O\-M (0018,1120) = 15  
\item {\ttfamily double = obj.\-Get\-Gantry\-Tilt\-As\-Double ()} -\/ Gantry/\-Detector tilt (Nominal angle of tilt in degrees of the scanning gantry.) For ex\-: D\-I\-C\-O\-M (0018,1120) = 15  
\item {\ttfamily obj.\-Set\-Echo\-Time (string )} -\/ Echo Time (Time in ms between the middle of the excitation pulse and the peak of the echo produced) For ex\-: D\-I\-C\-O\-M (0018,0081) = 105  
\item {\ttfamily string = obj.\-Get\-Echo\-Time ()} -\/ Echo Time (Time in ms between the middle of the excitation pulse and the peak of the echo produced) For ex\-: D\-I\-C\-O\-M (0018,0081) = 105  
\item {\ttfamily obj.\-Set\-Echo\-Train\-Length (string )} -\/ Echo Train Length (Number of lines in k-\/space acquired per excitation per image) For ex\-: D\-I\-C\-O\-M (0018,0091) = 35  
\item {\ttfamily string = obj.\-Get\-Echo\-Train\-Length ()} -\/ Echo Train Length (Number of lines in k-\/space acquired per excitation per image) For ex\-: D\-I\-C\-O\-M (0018,0091) = 35  
\item {\ttfamily obj.\-Set\-Repetition\-Time (string )} -\/ Repetition Time The period of time in msec between the beginning of a pulse sequence and the beginning of the succeeding (essentially identical) pulse sequence. For ex\-: D\-I\-C\-O\-M (0018,0080) = 2040  
\item {\ttfamily string = obj.\-Get\-Repetition\-Time ()} -\/ Repetition Time The period of time in msec between the beginning of a pulse sequence and the beginning of the succeeding (essentially identical) pulse sequence. For ex\-: D\-I\-C\-O\-M (0018,0080) = 2040  
\item {\ttfamily obj.\-Set\-Exposure\-Time (string )} -\/ Exposure time (time of x-\/ray exposure in msec) For ex\-: D\-I\-C\-O\-M (0018,1150) = 5  
\item {\ttfamily string = obj.\-Get\-Exposure\-Time ()} -\/ Exposure time (time of x-\/ray exposure in msec) For ex\-: D\-I\-C\-O\-M (0018,1150) = 5  
\item {\ttfamily obj.\-Set\-X\-Ray\-Tube\-Current (string )} -\/ X-\/ray tube current (in m\-A) For ex\-: D\-I\-C\-O\-M (0018,1151) = 400  
\item {\ttfamily string = obj.\-Get\-X\-Ray\-Tube\-Current ()} -\/ X-\/ray tube current (in m\-A) For ex\-: D\-I\-C\-O\-M (0018,1151) = 400  
\item {\ttfamily obj.\-Set\-Exposure (string )} -\/ Exposure (The exposure expressed in m\-As, for example calculated from Exposure Time and X-\/ray Tube Current) For ex\-: D\-I\-C\-O\-M (0018,1152) = 114  
\item {\ttfamily string = obj.\-Get\-Exposure ()} -\/ Exposure (The exposure expressed in m\-As, for example calculated from Exposure Time and X-\/ray Tube Current) For ex\-: D\-I\-C\-O\-M (0018,1152) = 114  
\item {\ttfamily obj.\-Set\-Direction\-Cosine (double , double , double , double , double , double )} -\/ Get the direction cosine (default to 1,0,0,0,1,0)  
\item {\ttfamily obj.\-Set\-Direction\-Cosine (double a\mbox{[}6\mbox{]})} -\/ Get the direction cosine (default to 1,0,0,0,1,0)  
\item {\ttfamily double = obj. Get\-Direction\-Cosine ()} -\/ Get the direction cosine (default to 1,0,0,0,1,0)  
\item {\ttfamily obj.\-Add\-User\-Defined\-Value (string name, string value)}  
\item {\ttfamily string = obj.\-Get\-User\-Defined\-Value (string name)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-User\-Defined\-Values ()}  
\item {\ttfamily string = obj.\-Get\-User\-Defined\-Name\-By\-Index (int idx)}  
\item {\ttfamily string = obj.\-Get\-User\-Defined\-Value\-By\-Index (int idx)}  
\item {\ttfamily obj.\-Remove\-All\-User\-Defined\-Values ()}  
\item {\ttfamily int = obj.\-Add\-Window\-Level\-Preset (double w, double l)} -\/ Add/\-Remove/\-Query the window/level presets that may have been associated to a medical image. Window is also known as 'width', level is also known as 'center'. The same window/level pair can not be added twice. As a convenience, a comment (aka Explanation) can be associated to a preset. For ex\-: \begin{DoxyVerb}         DICOM Window Center (0028,1050) = 00045\000470
         DICOM Window Width  (0028,1051) = 0106\03412
         DICOM Window Center Width Explanation (0028,1055) = WINDOW1\WINDOW2\end{DoxyVerb}
  
\item {\ttfamily obj.\-Remove\-Window\-Level\-Preset (double w, double l)} -\/ Add/\-Remove/\-Query the window/level presets that may have been associated to a medical image. Window is also known as 'width', level is also known as 'center'. The same window/level pair can not be added twice. As a convenience, a comment (aka Explanation) can be associated to a preset. For ex\-: \begin{DoxyVerb}         DICOM Window Center (0028,1050) = 00045\000470
         DICOM Window Width  (0028,1051) = 0106\03412
         DICOM Window Center Width Explanation (0028,1055) = WINDOW1\WINDOW2\end{DoxyVerb}
  
\item {\ttfamily obj.\-Remove\-All\-Window\-Level\-Presets ()} -\/ Add/\-Remove/\-Query the window/level presets that may have been associated to a medical image. Window is also known as 'width', level is also known as 'center'. The same window/level pair can not be added twice. As a convenience, a comment (aka Explanation) can be associated to a preset. For ex\-: \begin{DoxyVerb}         DICOM Window Center (0028,1050) = 00045\000470
         DICOM Window Width  (0028,1051) = 0106\03412
         DICOM Window Center Width Explanation (0028,1055) = WINDOW1\WINDOW2\end{DoxyVerb}
  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Window\-Level\-Presets ()} -\/ Add/\-Remove/\-Query the window/level presets that may have been associated to a medical image. Window is also known as 'width', level is also known as 'center'. The same window/level pair can not be added twice. As a convenience, a comment (aka Explanation) can be associated to a preset. For ex\-: \begin{DoxyVerb}         DICOM Window Center (0028,1050) = 00045\000470
         DICOM Window Width  (0028,1051) = 0106\03412
         DICOM Window Center Width Explanation (0028,1055) = WINDOW1\WINDOW2\end{DoxyVerb}
  
\item {\ttfamily int = obj.\-Has\-Window\-Level\-Preset (double w, double l)} -\/ Add/\-Remove/\-Query the window/level presets that may have been associated to a medical image. Window is also known as 'width', level is also known as 'center'. The same window/level pair can not be added twice. As a convenience, a comment (aka Explanation) can be associated to a preset. For ex\-: \begin{DoxyVerb}         DICOM Window Center (0028,1050) = 00045\000470
         DICOM Window Width  (0028,1051) = 0106\03412
         DICOM Window Center Width Explanation (0028,1055) = WINDOW1\WINDOW2\end{DoxyVerb}
  
\item {\ttfamily int = obj.\-Get\-Window\-Level\-Preset\-Index (double w, double l)} -\/ Add/\-Remove/\-Query the window/level presets that may have been associated to a medical image. Window is also known as 'width', level is also known as 'center'. The same window/level pair can not be added twice. As a convenience, a comment (aka Explanation) can be associated to a preset. For ex\-: \begin{DoxyVerb}         DICOM Window Center (0028,1050) = 00045\000470
         DICOM Window Width  (0028,1051) = 0106\03412
         DICOM Window Center Width Explanation (0028,1055) = WINDOW1\WINDOW2\end{DoxyVerb}
  
\item {\ttfamily int = obj.\-Get\-Nth\-Window\-Level\-Preset (int idx, double w, double l)} -\/ Add/\-Remove/\-Query the window/level presets that may have been associated to a medical image. Window is also known as 'width', level is also known as 'center'. The same window/level pair can not be added twice. As a convenience, a comment (aka Explanation) can be associated to a preset. For ex\-: \begin{DoxyVerb}         DICOM Window Center (0028,1050) = 00045\000470
         DICOM Window Width  (0028,1051) = 0106\03412
         DICOM Window Center Width Explanation (0028,1055) = WINDOW1\WINDOW2\end{DoxyVerb}
  
\item {\ttfamily double = obj.\-Get\-Nth\-Window\-Level\-Preset (int idx)} -\/ Add/\-Remove/\-Query the window/level presets that may have been associated to a medical image. Window is also known as 'width', level is also known as 'center'. The same window/level pair can not be added twice. As a convenience, a comment (aka Explanation) can be associated to a preset. For ex\-: \begin{DoxyVerb}         DICOM Window Center (0028,1050) = 00045\000470
         DICOM Window Width  (0028,1051) = 0106\03412
         DICOM Window Center Width Explanation (0028,1055) = WINDOW1\WINDOW2\end{DoxyVerb}
  
\item {\ttfamily obj.\-Set\-Nth\-Window\-Level\-Preset\-Comment (int idx, string comment)} -\/ Add/\-Remove/\-Query the window/level presets that may have been associated to a medical image. Window is also known as 'width', level is also known as 'center'. The same window/level pair can not be added twice. As a convenience, a comment (aka Explanation) can be associated to a preset. For ex\-: \begin{DoxyVerb}         DICOM Window Center (0028,1050) = 00045\000470
         DICOM Window Width  (0028,1051) = 0106\03412
         DICOM Window Center Width Explanation (0028,1055) = WINDOW1\WINDOW2\end{DoxyVerb}
  
\item {\ttfamily string = obj.\-Get\-Nth\-Window\-Level\-Preset\-Comment (int idx)} -\/ Add/\-Remove/\-Query the window/level presets that may have been associated to a medical image. Window is also known as 'width', level is also known as 'center'. The same window/level pair can not be added twice. As a convenience, a comment (aka Explanation) can be associated to a preset. For ex\-: \begin{DoxyVerb}         DICOM Window Center (0028,1050) = 00045\000470
         DICOM Window Width  (0028,1051) = 0106\03412
         DICOM Window Center Width Explanation (0028,1055) = WINDOW1\WINDOW2\end{DoxyVerb}
  
\item {\ttfamily string = obj.\-Get\-Instance\-U\-I\-D\-From\-Slice\-I\-D (int volumeidx, int sliceid)} -\/ Mapping from a sliceidx within a volumeidx into a D\-I\-C\-O\-M Instance U\-I\-D Some D\-I\-C\-O\-M reader can populate this structure so that later on from a slice index in a vtk\-Image\-Data volume we can backtrack and find out which 2d slice it was coming from  
\item {\ttfamily obj.\-Set\-Instance\-U\-I\-D\-From\-Slice\-I\-D (int volumeidx, int sliceid, string uid)} -\/ Mapping from a sliceidx within a volumeidx into a D\-I\-C\-O\-M Instance U\-I\-D Some D\-I\-C\-O\-M reader can populate this structure so that later on from a slice index in a vtk\-Image\-Data volume we can backtrack and find out which 2d slice it was coming from  
\item {\ttfamily int = obj.\-Get\-Orientation\-Type (int volumeidx)}  
\item {\ttfamily obj.\-Set\-Orientation\-Type (int volumeidx, int orientation)}  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Medical\-Image\-Properties p)} -\/ Copy the contents of p to this instance.  
\end{DoxyItemize}\hypertarget{vtkio_vtkmedicalimagereader2}{}\section{vtk\-Medical\-Image\-Reader2}\label{vtkio_vtkmedicalimagereader2}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Medical\-Image\-Reader2 is a parent class for medical image readers. It provides a place to store patient information that may be stored in the image header.

To create an instance of class vtk\-Medical\-Image\-Reader2, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMedicalImageReader2
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Medical\-Image\-Reader2 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\-Medical\-Image\-Reader2 class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Medical\-Image\-Reader2 = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Medical\-Image\-Reader2 = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Medical\-Image\-Properties = obj.\-Get\-Medical\-Image\-Properties ()} -\/ Get the medical image properties object  
\item {\ttfamily obj.\-Set\-Patient\-Name (string )} -\/ For backward compatibility, propagate calls to the Medical\-Image\-Properties object.  
\item {\ttfamily string = obj.\-Get\-Patient\-Name ()} -\/ For backward compatibility, propagate calls to the Medical\-Image\-Properties object.  
\item {\ttfamily obj.\-Set\-Patient\-I\-D (string )} -\/ For backward compatibility, propagate calls to the Medical\-Image\-Properties object.  
\item {\ttfamily string = obj.\-Get\-Patient\-I\-D ()} -\/ For backward compatibility, propagate calls to the Medical\-Image\-Properties object.  
\item {\ttfamily obj.\-Set\-Date (string )} -\/ For backward compatibility, propagate calls to the Medical\-Image\-Properties object.  
\item {\ttfamily string = obj.\-Get\-Date ()} -\/ For backward compatibility, propagate calls to the Medical\-Image\-Properties object.  
\item {\ttfamily obj.\-Set\-Series (string )} -\/ For backward compatibility, propagate calls to the Medical\-Image\-Properties object.  
\item {\ttfamily string = obj.\-Get\-Series ()} -\/ For backward compatibility, propagate calls to the Medical\-Image\-Properties object.  
\item {\ttfamily obj.\-Set\-Study (string )} -\/ For backward compatibility, propagate calls to the Medical\-Image\-Properties object.  
\item {\ttfamily string = obj.\-Get\-Study ()} -\/ For backward compatibility, propagate calls to the Medical\-Image\-Properties object.  
\item {\ttfamily obj.\-Set\-Image\-Number (string )} -\/ For backward compatibility, propagate calls to the Medical\-Image\-Properties object.  
\item {\ttfamily string = obj.\-Get\-Image\-Number ()} -\/ For backward compatibility, propagate calls to the Medical\-Image\-Properties object.  
\item {\ttfamily obj.\-Set\-Modality (string )} -\/ For backward compatibility, propagate calls to the Medical\-Image\-Properties object.  
\item {\ttfamily string = obj.\-Get\-Modality ()} -\/ For backward compatibility, propagate calls to the Medical\-Image\-Properties object.  
\end{DoxyItemize}\hypertarget{vtkio_vtkmetaimagereader}{}\section{vtk\-Meta\-Image\-Reader}\label{vtkio_vtkmetaimagereader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
One of the formats for which a reader is already available in the toolkit is the Meta\-Image file format. This is a fairly simple yet powerful format consisting of a text header and a binary data section. The following instructions describe how you can write a Meta\-Image header for the data that you download from the Brain\-Web page.

The minimal structure of the Meta\-Image header is the following\-:

N\-Dims = 3 Dim\-Size = 181 217 181 Element\-Type = M\-E\-T\-\_\-\-U\-C\-H\-A\-R Element\-Spacing = 1.\-0 1.\-0 1.\-0 Element\-Byte\-Order\-M\-S\-B = False Element\-Data\-File = brainweb1.\-raw

N\-Dims indicate that this is a 3\-D image. I\-T\-K can handle images of arbitrary dimension. Dim\-Size indicates the size of the volume in pixels along each direction. Element\-Type indicate the primitive type used for pixels. In this case is \char`\"{}unsigned char\char`\"{}, implying that the data is digitized in 8 bits / pixel. Element\-Spacing indicates the physical separation between the center of one pixel and the center of the next pixel along each direction in space. The units used are millimeters. Element\-Byte\-Order\-M\-S\-B indicates is the data is encoded in little or big endian order. You might want to play with this value when moving data between different computer platforms. Element\-Data\-File is the name of the file containing the raw binary data of the image. This file must be in the same directory as the header.

Meta\-Image headers are expected to have extension\-: \char`\"{}.\-mha\char`\"{} or \char`\"{}.\-mhd\char`\"{}

Once you write this header text file, it should be possible to read the image into your I\-T\-K based application using the itk\-::\-File\-I\-O\-To\-Image\-Filter class.

To create an instance of class vtk\-Meta\-Image\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMetaImageReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Meta\-Image\-Reader 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\-Meta\-Image\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Meta\-Image\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Meta\-Image\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily string = obj.\-Get\-File\-Extensions ()}  
\item {\ttfamily string = obj.\-Get\-Descriptive\-Name ()}  
\item {\ttfamily int = obj.\-Get\-Width ()}  
\item {\ttfamily int = obj.\-Get\-Height ()}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components ()}  
\item {\ttfamily int = obj.\-Get\-Pixel\-Representation ()}  
\item {\ttfamily int = obj.\-Get\-Data\-Byte\-Order (void )}  
\item {\ttfamily double = obj.\-Get\-Rescale\-Slope ()}  
\item {\ttfamily double = obj.\-Get\-Rescale\-Offset ()}  
\item {\ttfamily int = obj.\-Get\-Bits\-Allocated ()}  
\item {\ttfamily string = obj.\-Get\-Distance\-Units ()}  
\item {\ttfamily string = obj.\-Get\-Anatomical\-Orientation ()}  
\item {\ttfamily double = obj.\-Get\-Gantry\-Angle ()}  
\item {\ttfamily string = obj.\-Get\-Patient\-Name ()}  
\item {\ttfamily string = obj.\-Get\-Patient\-I\-D ()}  
\item {\ttfamily string = obj.\-Get\-Date ()}  
\item {\ttfamily string = obj.\-Get\-Series ()}  
\item {\ttfamily string = obj.\-Get\-Image\-Number ()}  
\item {\ttfamily string = obj.\-Get\-Modality ()}  
\item {\ttfamily string = obj.\-Get\-Study\-I\-D ()}  
\item {\ttfamily string = obj.\-Get\-Study\-U\-I\-D ()}  
\item {\ttfamily string = obj.\-Get\-Transfer\-Syntax\-U\-I\-D ()}  
\item {\ttfamily int = obj.\-Can\-Read\-File (string name)} -\/ Test whether the file with the given name can be read by this reader.  
\end{DoxyItemize}\hypertarget{vtkio_vtkmetaimagewriter}{}\section{vtk\-Meta\-Image\-Writer}\label{vtkio_vtkmetaimagewriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
One of the formats for which a reader is already available in the toolkit is the Meta\-Image file format. This is a fairly simple yet powerful format consisting of a text header and a binary data section. The following instructions describe how you can write a Meta\-Image header for the data that you download from the Brain\-Web page.

The minimal structure of the Meta\-Image header is the following\-:

N\-Dims = 3 Dim\-Size = 181 217 181 Element\-Type = M\-E\-T\-\_\-\-U\-C\-H\-A\-R Element\-Spacing = 1.\-0 1.\-0 1.\-0 Element\-Byte\-Order\-M\-S\-B = False Element\-Data\-File = brainweb1.\-raw

N\-Dims indicate that this is a 3\-D image. I\-T\-K can handle images of arbitrary dimension. Dim\-Size indicates the size of the volume in pixels along each direction. Element\-Type indicate the primitive type used for pixels. In this case is \char`\"{}unsigned char\char`\"{}, implying that the data is digitized in 8 bits / pixel. Element\-Spacing indicates the physical separation between the center of one pixel and the center of the next pixel along each direction in space. The units used are millimeters. Element\-Byte\-Order\-M\-S\-B indicates is the data is encoded in little or big endian order. You might want to play with this value when moving data between different computer platforms. Element\-Data\-File is the name of the file containing the raw binary data of the image. This file must be in the same directory as the header.

Meta\-Image headers are expected to have extension\-: \char`\"{}.\-mha\char`\"{} or \char`\"{}.\-mhd\char`\"{}

Once you write this header text file, it should be possible to read the image into your I\-T\-K based application using the itk\-::\-File\-I\-O\-To\-Image\-Filter class.

To create an instance of class vtk\-Meta\-Image\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMetaImageWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Meta\-Image\-Writer 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\-Meta\-Image\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Meta\-Image\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Meta\-Image\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string fname)} -\/ Specify file name of meta file  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify the file name of the raw image data.  
\item {\ttfamily obj.\-Set\-R\-A\-W\-File\-Name (string fname)} -\/ Specify the file name of the raw image data.  
\item {\ttfamily string = obj.\-Get\-R\-A\-W\-File\-Name ()} -\/ Specify the file name of the raw image data.  
\item {\ttfamily obj.\-Set\-Compression (bool compress)}  
\item {\ttfamily bool = obj.\-Get\-Compression (void )}  
\item {\ttfamily obj.\-Write ()}  
\end{DoxyItemize}\hypertarget{vtkio_vtkmfixreader}{}\section{vtk\-M\-F\-I\-X\-Reader}\label{vtkio_vtkmfixreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-M\-F\-I\-X\-Reader creates an unstructured grid dataset. It reads a restart file and a set of sp files. The restart file contains the mesh information. M\-F\-I\-X meshes are either cylindrical or rectilinear, but this reader will convert them to an unstructured grid. The sp files contain transient data for the cells. Each sp file has one or more variables stored inside it.

To create an instance of class vtk\-M\-F\-I\-X\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMFIXReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-M\-F\-I\-X\-Reader 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\-M\-F\-I\-X\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-M\-F\-I\-X\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-M\-F\-I\-X\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify the file name of the M\-F\-I\-X Restart data file to read.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify the file name of the M\-F\-I\-X Restart data file to read.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Cells ()} -\/ Get the total number of cells. The number of cells is only valid after a successful read of the data file is performed.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Points ()} -\/ Get the total number of nodes. The number of nodes is only valid after a successful read of the data file is performed.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Cell\-Fields ()} -\/ Get the number of data components at the nodes and cells.  
\item {\ttfamily obj.\-Set\-Time\-Step (int )} -\/ Which Time\-Step to read.  
\item {\ttfamily int = obj.\-Get\-Time\-Step ()} -\/ Which Time\-Step to read.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Time\-Steps ()} -\/ Returns the number of timesteps.  
\item {\ttfamily int = obj. Get\-Time\-Step\-Range ()} -\/ Which Time\-Step\-Range to read  
\item {\ttfamily obj.\-Set\-Time\-Step\-Range (int , int )} -\/ Which Time\-Step\-Range to read  
\item {\ttfamily obj.\-Set\-Time\-Step\-Range (int a\mbox{[}2\mbox{]})} -\/ Which Time\-Step\-Range to read  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Cell\-Arrays (void )}  
\item {\ttfamily string = obj.\-Get\-Cell\-Array\-Name (int index)} -\/ Get the name of the cell array with the given index in the input.  
\item {\ttfamily int = obj.\-Get\-Cell\-Array\-Status (string name)} -\/ Get/\-Set whether the cell array with the given name is to be read.  
\item {\ttfamily obj.\-Set\-Cell\-Array\-Status (string name, int status)} -\/ Get/\-Set whether the cell array with the given name is to be read.  
\item {\ttfamily obj.\-Disable\-All\-Cell\-Arrays ()} -\/ Turn on/off all cell arrays.  
\item {\ttfamily obj.\-Enable\-All\-Cell\-Arrays ()} -\/ Turn on/off all cell arrays.  
\item {\ttfamily obj.\-Get\-Cell\-Data\-Range (int cell\-Comp, int index, float min, float max)} -\/ Get the range of cell data.  
\end{DoxyItemize}\hypertarget{vtkio_vtkmincimageattributes}{}\section{vtk\-M\-I\-N\-C\-Image\-Attributes}\label{vtkio_vtkmincimageattributes}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class provides methods to access all of the information contained in the M\-I\-N\-C header. If you read a M\-I\-N\-C file into V\-T\-K and then write it out again, you can use writer-\/$>$Set\-Image\-Attributes(reader-\/$>$Get\-Image\-Attributes) to ensure that all of the medical information contained in the file is tranferred from the reader to the writer. If you want to change any of the header information, you must use Shallow\-Copy to make a copy of the reader's attributes and then modify only the copy.

To create an instance of class vtk\-M\-I\-N\-C\-Image\-Attributes, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMINCImageAttributes
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-M\-I\-N\-C\-Image\-Attributes 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\-M\-I\-N\-C\-Image\-Attributes class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-M\-I\-N\-C\-Image\-Attributes = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-M\-I\-N\-C\-Image\-Attributes = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Reset ()} -\/ Reset all the attributes in preparation for loading new information.  
\item {\ttfamily obj.\-Set\-Name (string )} -\/ Get the name of the image, not including the path or the extension. This is only needed for printing the header and there is usually no need to set it.  
\item {\ttfamily string = obj.\-Get\-Name ()} -\/ Get the name of the image, not including the path or the extension. This is only needed for printing the header and there is usually no need to set it.  
\item {\ttfamily obj.\-Set\-Data\-Type (int )} -\/ Get the image data type, as stored on disk. This information is useful if the file was converted to floating-\/point when it was loaded. When writing a file from float or double image data, you can use this method to prescribe the output type.  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()} -\/ Get the image data type, as stored on disk. This information is useful if the file was converted to floating-\/point when it was loaded. When writing a file from float or double image data, you can use this method to prescribe the output type.  
\item {\ttfamily obj.\-Add\-Dimension (string dimension)} -\/ Add the names of up to five dimensions. The ordering of these dimensions will determine the dimension order of the file. If no Dimension\-Names are set, the writer will set the dimension order of the file to be the same as the dimension order in memory.  
\item {\ttfamily obj.\-Add\-Dimension (string dimension, vtk\-Id\-Type length)} -\/ Add the names of up to five dimensions. The ordering of these dimensions will determine the dimension order of the file. If no Dimension\-Names are set, the writer will set the dimension order of the file to be the same as the dimension order in memory.  
\item {\ttfamily vtk\-String\-Array = obj.\-Get\-Dimension\-Names ()} -\/ Get the dimension names. The dimension names are same order as written in the file, starting with the slowest-\/varying dimension. Use this method to get the array if you need to change \char`\"{}space\char`\"{} dimensions to \char`\"{}frequency\char`\"{} after performing a Fourier transform.  
\item {\ttfamily vtk\-Id\-Type\-Array = obj.\-Get\-Dimension\-Lengths ()} -\/ Get the lengths of all the dimensions. The dimension lengths are informative, the vtk\-M\-I\-N\-C\-Image\-Writer does not look at these values but instead uses the dimension sizes of its input.  
\item {\ttfamily vtk\-String\-Array = obj.\-Get\-Variable\-Names ()} -\/ Get the names of all the variables.  
\item {\ttfamily vtk\-String\-Array = obj.\-Get\-Attribute\-Names (string variable)} -\/ List the attribute names for a variable. Set the variable to the empty string to get a list of the global attributes.  
\item {\ttfamily obj.\-Set\-Image\-Min (vtk\-Double\-Array image\-Min)} -\/ Get the image min and max arrays. These are set by the reader, but they aren't used by the writer except to compute the full real data range of the original file.  
\item {\ttfamily obj.\-Set\-Image\-Max (vtk\-Double\-Array image\-Max)} -\/ Get the image min and max arrays. These are set by the reader, but they aren't used by the writer except to compute the full real data range of the original file.  
\item {\ttfamily vtk\-Double\-Array = obj.\-Get\-Image\-Min ()} -\/ Get the image min and max arrays. These are set by the reader, but they aren't used by the writer except to compute the full real data range of the original file.  
\item {\ttfamily vtk\-Double\-Array = obj.\-Get\-Image\-Max ()} -\/ Get the image min and max arrays. These are set by the reader, but they aren't used by the writer except to compute the full real data range of the original file.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Image\-Min\-Max\-Dimensions ()} -\/ Get the number of Image\-Min\-Max dimensions.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Image\-Min\-Max\-Dimensions (int )} -\/ Get the number of Image\-Min\-Max dimensions.  
\item {\ttfamily int = obj.\-Has\-Attribute (string variable, string attribute)} -\/ Check to see if a particular attribute exists.  
\item {\ttfamily obj.\-Set\-Attribute\-Value\-As\-Array (string variable, string attribute, vtk\-Data\-Array array)} -\/ Set attribute values for a variable as a vtk\-Data\-Array. Set the variable to the empty string to access global attributes.  
\item {\ttfamily vtk\-Data\-Array = obj.\-Get\-Attribute\-Value\-As\-Array (string variable, string attribute)} -\/ Set attribute values for a variable as a vtk\-Data\-Array. Set the variable to the empty string to access global attributes.  
\item {\ttfamily obj.\-Set\-Attribute\-Value\-As\-String (string variable, string attribute, string value)} -\/ Set an attribute value as a string. Set the variable to the empty string to access global attributes. If you specify a variable that does not exist, it will be created.  
\item {\ttfamily string = obj.\-Get\-Attribute\-Value\-As\-String (string variable, string attribute)} -\/ Set an attribute value as a string. Set the variable to the empty string to access global attributes. If you specify a variable that does not exist, it will be created.  
\item {\ttfamily obj.\-Set\-Attribute\-Value\-As\-Int (string variable, string attribute, int value)} -\/ Set an attribute value as an int. Set the variable to the empty string to access global attributes. If you specify a variable that does not exist, it will be created.  
\item {\ttfamily int = obj.\-Get\-Attribute\-Value\-As\-Int (string variable, string attribute)} -\/ Set an attribute value as an int. Set the variable to the empty string to access global attributes. If you specify a variable that does not exist, it will be created.  
\item {\ttfamily obj.\-Set\-Attribute\-Value\-As\-Double (string variable, string attribute, double value)} -\/ Set an attribute value as a double. Set the variable to the empty string to access global attributes. If you specify a variable that does not exist, it will be created.  
\item {\ttfamily double = obj.\-Get\-Attribute\-Value\-As\-Double (string variable, string attribute)} -\/ Set an attribute value as a double. Set the variable to the empty string to access global attributes. If you specify a variable that does not exist, it will be created.  
\item {\ttfamily int = obj.\-Validate\-Attribute (string varname, string attname, vtk\-Data\-Array array)} -\/ Validate a particular attribute. This involves checking that the attribute is a M\-I\-N\-C standard attribute, and checking whether it can be set (as opposed to being set automatically from the image information). The return values is 0 if the attribute is set automatically and therefore should not be copied from here, 1 if this attribute is valid and should be set, and 2 if the attribute is non-\/standard.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-M\-I\-N\-C\-Image\-Attributes source)} -\/ Do a shallow copy. This will copy all the attributes from the source. It is much more efficient than a Deep\-Copy would be, since it only copies pointers to the attribute values instead of copying the arrays themselves. You must use this method to make a copy if you want to modify any M\-I\-N\-C attributes from a M\-I\-N\-C\-Reader before you pass them to a M\-I\-N\-C\-Writer.  
\item {\ttfamily obj.\-Find\-Valid\-Range (double range\mbox{[}2\mbox{]})} -\/ Find the valid range of the data from the information stored in the attributes.  
\item {\ttfamily obj.\-Find\-Image\-Range (double range\mbox{[}2\mbox{]})} -\/ Find the image range of the data from the information stored in the attributes.  
\item {\ttfamily obj.\-Print\-File\-Header ()} -\/ A diagnostic function. Print the header of the file in the same format as ncdump or mincheader.  
\end{DoxyItemize}\hypertarget{vtkio_vtkmincimagereader}{}\section{vtk\-M\-I\-N\-C\-Image\-Reader}\label{vtkio_vtkmincimagereader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
M\-I\-N\-C is a Net\-C\-D\-F-\/based medical image file format that was developed at the Montreal Neurological Institute in 1992. This class will read a M\-I\-N\-C file into V\-T\-K, rearranging the data to match the V\-T\-K x, y, and z dimensions, and optionally rescaling real-\/valued data to V\-T\-K\-\_\-\-F\-L\-O\-A\-T if Rescale\-Real\-Values\-On() is set. If Rescale\-Real\-Values is off, then the data will be stored in its original data type and the Get\-Rescale\-Slope(), Get\-Rescale\-Intercept() method can be used to retrieve global rescaling parameters. If the original file had a time dimension, the Set\-Time\-Step() method can be used to specify a time step to read. All of the original header information can be accessed though the Get\-Image\-Attributes() method.

To create an instance of class vtk\-M\-I\-N\-C\-Image\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMINCImageReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-M\-I\-N\-C\-Image\-Reader 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\-M\-I\-N\-C\-Image\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-M\-I\-N\-C\-Image\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-M\-I\-N\-C\-Image\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string name)} -\/ Set the file name.  
\item {\ttfamily string = obj.\-Get\-File\-Extensions ()} -\/ Get the name of this file format.  
\item {\ttfamily string = obj.\-Get\-Descriptive\-Name ()} -\/ Test whether the specified file can be read.  
\item {\ttfamily int = obj.\-Can\-Read\-File (string name)} -\/ Test whether the specified file can be read.  
\item {\ttfamily vtk\-Matrix4x4 = obj.\-Get\-Direction\-Cosines ()} -\/ Get a matrix that describes the orientation of the data. The three columns of the matrix are the direction cosines for the x, y and z dimensions respectively.  
\item {\ttfamily double = obj.\-Get\-Rescale\-Slope ()} -\/ Get the slope and intercept for rescaling the scalar values to real data values. To convert scalar values to real values, use the equation y = x$\ast$\-Rescale\-Slope + Rescale\-Intercept.  
\item {\ttfamily double = obj.\-Get\-Rescale\-Intercept ()} -\/ Get the slope and intercept for rescaling the scalar values to real data values. To convert scalar values to real values, use the equation y = x$\ast$\-Rescale\-Slope + Rescale\-Intercept.  
\item {\ttfamily obj.\-Set\-Rescale\-Real\-Values (int )} -\/ Rescale real data values to float. If this is done, the Rescale\-Slope and Rescale\-Intercept will be set to 1 and 0 respectively. This is off by default.  
\item {\ttfamily obj.\-Rescale\-Real\-Values\-On ()} -\/ Rescale real data values to float. If this is done, the Rescale\-Slope and Rescale\-Intercept will be set to 1 and 0 respectively. This is off by default.  
\item {\ttfamily obj.\-Rescale\-Real\-Values\-Off ()} -\/ Rescale real data values to float. If this is done, the Rescale\-Slope and Rescale\-Intercept will be set to 1 and 0 respectively. This is off by default.  
\item {\ttfamily int = obj.\-Get\-Rescale\-Real\-Values ()} -\/ Rescale real data values to float. If this is done, the Rescale\-Slope and Rescale\-Intercept will be set to 1 and 0 respectively. This is off by default.  
\item {\ttfamily double = obj.\-Get\-Data\-Range ()} -\/ Get the scalar range of the output from the information in the file header. This is more efficient that computing the scalar range, but in some cases the M\-I\-N\-C file stores an incorrect valid\-\_\-range and the Data\-Range will be incorrect.  
\item {\ttfamily obj.\-Get\-Data\-Range (double range\mbox{[}2\mbox{]})} -\/ Get the scalar range of the output from the information in the file header. This is more efficient that computing the scalar range, but in some cases the M\-I\-N\-C file stores an incorrect valid\-\_\-range and the Data\-Range will be incorrect.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Time\-Steps ()} -\/ Get the number of time steps in the file.  
\item {\ttfamily obj.\-Set\-Time\-Step (int )} -\/ Set the time step to read.  
\item {\ttfamily int = obj.\-Get\-Time\-Step ()} -\/ Set the time step to read.  
\item {\ttfamily vtk\-M\-I\-N\-C\-Image\-Attributes = obj.\-Get\-Image\-Attributes ()} -\/ Get the image attributes, which contain patient information and other useful metadata.  
\end{DoxyItemize}\hypertarget{vtkio_vtkmincimagewriter}{}\section{vtk\-M\-I\-N\-C\-Image\-Writer}\label{vtkio_vtkmincimagewriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
M\-I\-N\-C is a Net\-C\-D\-F-\/based medical image file format that was developed at the Montreal Neurological Institute in 1992. The data is written slice-\/by-\/slice, and this writer is therefore suitable for streaming M\-I\-N\-C data that is larger than the memory size through V\-T\-K. This writer can also produce files with up to 4 dimensions, where the fourth dimension is provided by using Add\-Input() to specify multiple input data sets. If you want to set header information for the file, you must supply a vtk\-M\-I\-N\-C\-Image\-Attributes

To create an instance of class vtk\-M\-I\-N\-C\-Image\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMINCImageWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-M\-I\-N\-C\-Image\-Writer 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\-M\-I\-N\-C\-Image\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-M\-I\-N\-C\-Image\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-M\-I\-N\-C\-Image\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily string = obj.\-Get\-File\-Extensions ()} -\/ Get the name of this file format.  
\item {\ttfamily string = obj.\-Get\-Descriptive\-Name ()} -\/ Set the file name.  
\item {\ttfamily obj.\-Set\-File\-Name (string name)} -\/ Set the file name.  
\item {\ttfamily obj.\-Write ()} -\/ Write the data. This will attempt to stream the data slice-\/by-\/slice through the pipeline and out to the file, unless the whole extent of the input has already been updated.  
\item {\ttfamily obj.\-Set\-Direction\-Cosines (vtk\-Matrix4x4 matrix)} -\/ Set a matrix that describes the orientation of the data. The three columns of this matrix should give the unit-\/vector directions for the V\-T\-K x, y and z dimensions respectively. The writer will use this information to determine how to map the V\-T\-K dimensions to the canonical M\-I\-N\-C dimensions, and if necessary, the writer will re-\/order one or more dimensions back-\/to-\/front to ensure that no M\-I\-N\-C dimension ends up with a direction cosines vector whose dot product with the canonical unit vector for that dimension is negative.  
\item {\ttfamily vtk\-Matrix4x4 = obj.\-Get\-Direction\-Cosines ()} -\/ Set a matrix that describes the orientation of the data. The three columns of this matrix should give the unit-\/vector directions for the V\-T\-K x, y and z dimensions respectively. The writer will use this information to determine how to map the V\-T\-K dimensions to the canonical M\-I\-N\-C dimensions, and if necessary, the writer will re-\/order one or more dimensions back-\/to-\/front to ensure that no M\-I\-N\-C dimension ends up with a direction cosines vector whose dot product with the canonical unit vector for that dimension is negative.  
\item {\ttfamily obj.\-Set\-Rescale\-Slope (double )} -\/ Set the slope and intercept for rescaling the intensities. The default values are zero, which indicates to the reader that no rescaling is to be performed.  
\item {\ttfamily double = obj.\-Get\-Rescale\-Slope ()} -\/ Set the slope and intercept for rescaling the intensities. The default values are zero, which indicates to the reader that no rescaling is to be performed.  
\item {\ttfamily obj.\-Set\-Rescale\-Intercept (double )} -\/ Set the slope and intercept for rescaling the intensities. The default values are zero, which indicates to the reader that no rescaling is to be performed.  
\item {\ttfamily double = obj.\-Get\-Rescale\-Intercept ()} -\/ Set the slope and intercept for rescaling the intensities. The default values are zero, which indicates to the reader that no rescaling is to be performed.  
\item {\ttfamily obj.\-Set\-Image\-Attributes (vtk\-M\-I\-N\-C\-Image\-Attributes attributes)} -\/ Set the image attributes, which contain patient information and other useful metadata.  
\item {\ttfamily vtk\-M\-I\-N\-C\-Image\-Attributes = obj.\-Get\-Image\-Attributes ()} -\/ Set the image attributes, which contain patient information and other useful metadata.  
\item {\ttfamily obj.\-Set\-Strict\-Validation (int )} -\/ Set whether to validate that all variable attributes that have been set are ones that are listed in the M\-I\-N\-C standard.  
\item {\ttfamily obj.\-Strict\-Validation\-On ()} -\/ Set whether to validate that all variable attributes that have been set are ones that are listed in the M\-I\-N\-C standard.  
\item {\ttfamily obj.\-Strict\-Validation\-Off ()} -\/ Set whether to validate that all variable attributes that have been set are ones that are listed in the M\-I\-N\-C standard.  
\item {\ttfamily int = obj.\-Get\-Strict\-Validation ()} -\/ Set whether to validate that all variable attributes that have been set are ones that are listed in the M\-I\-N\-C standard.  
\item {\ttfamily obj.\-Set\-History\-Addition (string )} -\/ Set a string value to append to the history of the file. This string should describe, briefly, how the file was processed.  
\item {\ttfamily string = obj.\-Get\-History\-Addition ()} -\/ Set a string value to append to the history of the file. This string should describe, briefly, how the file was processed.  
\end{DoxyItemize}\hypertarget{vtkio_vtkmoleculereaderbase}{}\section{vtk\-Molecule\-Reader\-Base}\label{vtkio_vtkmoleculereaderbase}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Molecule\-Reader\-Base is a source object that reads Molecule files The File\-Name must be specified

.S\-E\-C\-T\-I\-O\-N Thanks Dr. Jean M. Favre who developed and contributed this class

To create an instance of class vtk\-Molecule\-Reader\-Base, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMoleculeReaderBase
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Molecule\-Reader\-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\-Molecule\-Reader\-Base class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Molecule\-Reader\-Base = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Molecule\-Reader\-Base = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )}  
\item {\ttfamily string = obj.\-Get\-File\-Name ()}  
\item {\ttfamily obj.\-Set\-B\-Scale (double )}  
\item {\ttfamily double = obj.\-Get\-B\-Scale ()}  
\item {\ttfamily obj.\-Set\-H\-B\-Scale (double )}  
\item {\ttfamily double = obj.\-Get\-H\-B\-Scale ()}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Atoms ()}  
\end{DoxyItemize}\hypertarget{vtkio_vtkmultiblockplot3dreader}{}\section{vtk\-Multi\-Block\-P\-L\-O\-T3\-D\-Reader}\label{vtkio_vtkmultiblockplot3dreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Multi\-Block\-P\-L\-O\-T3\-D\-Reader is a reader object that reads P\-L\-O\-T3\-D formatted files and generates structured grid(s) on output. P\-L\-O\-T3\-D is a computer graphics program designed to visualize the grids and solutions of computational fluid dynamics. Please see the \char`\"{}\-P\-L\-O\-T3\-D User's Manual\char`\"{} available from N\-A\-S\-A Ames Research Center, Moffett Field C\-A.

P\-L\-O\-T3\-D files consist of a grid file (also known as X\-Y\-Z file), an optional solution file (also known as a Q file), and an optional function file that contains user created data (currently unsupported). The Q file contains solution information as follows\-: the four parameters free stream mach number (Fsmach), angle of attack (Alpha), Reynolds number (Re), and total integration time (Time). This information is stored in an array called Properties in the Field\-Data of each output (tuple 0\-: fsmach, tuple 1\-: alpha, tuple 2\-: re, tuple 3\-: time). In addition, the solution file contains the flow density (scalar), flow momentum (vector), and flow energy (scalar).

The reader can generate additional scalars and vectors (or \char`\"{}functions\char`\"{}) from this information. To use vtk\-Multi\-Block\-P\-L\-O\-T3\-D\-Reader, you must specify the particular function number for the scalar and vector you want to visualize. This implementation of the reader provides the following functions. The scalar functions are\-: -\/1 -\/ don't read or compute any scalars 100 -\/ density 110 -\/ pressure 120 -\/ temperature 130 -\/ enthalpy 140 -\/ internal energy 144 -\/ kinetic energy 153 -\/ velocity magnitude 163 -\/ stagnation energy 170 -\/ entropy 184 -\/ swirl.

The vector functions are\-: -\/1 -\/ don't read or compute any vectors 200 -\/ velocity 201 -\/ vorticity 202 -\/ momentum 210 -\/ pressure gradient.

(Other functions are described in the P\-L\-O\-T3\-D spec, but only those listed are implemented here.) Note that by default, this reader creates the density scalar (100) and momentum vector (202) as output. (These are just read in from the solution file.) Please note that the validity of computation is a function of this class's gas constants (R, Gamma) and the equations used. They may not be suitable for your computational domain.

Additionally, you can read other data and associate it as a vtk\-Data\-Array into the output's point attribute data. Use the method Add\-Function() to list all the functions that you'd like to read. Add\-Function() accepts an integer parameter that defines the function number.

To create an instance of class vtk\-Multi\-Block\-P\-L\-O\-T3\-D\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMultiBlockPLOT3DReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Multi\-Block\-P\-L\-O\-T3\-D\-Reader 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\-Block\-P\-L\-O\-T3\-D\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Multi\-Block\-P\-L\-O\-T3\-D\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Multi\-Block\-P\-L\-O\-T3\-D\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string name)} -\/ Set/\-Get the P\-L\-O\-T3\-D geometry filename.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Set/\-Get the P\-L\-O\-T3\-D geometry filename.  
\item {\ttfamily obj.\-Set\-X\-Y\-Z\-File\-Name (string )} -\/ Set/\-Get the P\-L\-O\-T3\-D geometry filename.  
\item {\ttfamily string = obj.\-Get\-X\-Y\-Z\-File\-Name ()} -\/ Set/\-Get the P\-L\-O\-T3\-D geometry filename.  
\item {\ttfamily obj.\-Set\-Q\-File\-Name (string )} -\/ Set/\-Get the P\-L\-O\-T3\-D solution filename.  
\item {\ttfamily string = obj.\-Get\-Q\-File\-Name ()} -\/ Set/\-Get the P\-L\-O\-T3\-D solution filename.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Blocks ()} -\/ This returns the number of outputs this reader will produce. This number is equal to the number of grids in the current file. This method has to be called before getting any output if the number of outputs will be greater than 1 (the first output is always the same). Note that every time this method is invoked, the header file is opened and part of the header is read.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Grids ()} -\/ Is the file to be read written in binary format (as opposed to ascii).  
\item {\ttfamily obj.\-Set\-Binary\-File (int )} -\/ Is the file to be read written in binary format (as opposed to ascii).  
\item {\ttfamily int = obj.\-Get\-Binary\-File ()} -\/ Is the file to be read written in binary format (as opposed to ascii).  
\item {\ttfamily obj.\-Binary\-File\-On ()} -\/ Is the file to be read written in binary format (as opposed to ascii).  
\item {\ttfamily obj.\-Binary\-File\-Off ()} -\/ Is the file to be read written in binary format (as opposed to ascii).  
\item {\ttfamily obj.\-Set\-Multi\-Grid (int )} -\/ Does the file to be read contain information about number of grids. In some P\-L\-O\-T3\-D files, the first value contains the number of grids (even if there is only 1). If reading such a file, set this to true.  
\item {\ttfamily int = obj.\-Get\-Multi\-Grid ()} -\/ Does the file to be read contain information about number of grids. In some P\-L\-O\-T3\-D files, the first value contains the number of grids (even if there is only 1). If reading such a file, set this to true.  
\item {\ttfamily obj.\-Multi\-Grid\-On ()} -\/ Does the file to be read contain information about number of grids. In some P\-L\-O\-T3\-D files, the first value contains the number of grids (even if there is only 1). If reading such a file, set this to true.  
\item {\ttfamily obj.\-Multi\-Grid\-Off ()} -\/ Does the file to be read contain information about number of grids. In some P\-L\-O\-T3\-D files, the first value contains the number of grids (even if there is only 1). If reading such a file, set this to true.  
\item {\ttfamily obj.\-Set\-Has\-Byte\-Count (int )} -\/ Were the arrays written with leading and trailing byte counts ? Usually, files written by a fortran program will contain these byte counts whereas the ones written by C/\-C++ won't.  
\item {\ttfamily int = obj.\-Get\-Has\-Byte\-Count ()} -\/ Were the arrays written with leading and trailing byte counts ? Usually, files written by a fortran program will contain these byte counts whereas the ones written by C/\-C++ won't.  
\item {\ttfamily obj.\-Has\-Byte\-Count\-On ()} -\/ Were the arrays written with leading and trailing byte counts ? Usually, files written by a fortran program will contain these byte counts whereas the ones written by C/\-C++ won't.  
\item {\ttfamily obj.\-Has\-Byte\-Count\-Off ()} -\/ Were the arrays written with leading and trailing byte counts ? Usually, files written by a fortran program will contain these byte counts whereas the ones written by C/\-C++ won't.  
\item {\ttfamily obj.\-Set\-I\-Blanking (int )} -\/ Is there iblanking (point visibility) information in the file. If there is iblanking arrays, these will be read and assigned to the Point\-Visibility array of the output.  
\item {\ttfamily int = obj.\-Get\-I\-Blanking ()} -\/ Is there iblanking (point visibility) information in the file. If there is iblanking arrays, these will be read and assigned to the Point\-Visibility array of the output.  
\item {\ttfamily obj.\-I\-Blanking\-On ()} -\/ Is there iblanking (point visibility) information in the file. If there is iblanking arrays, these will be read and assigned to the Point\-Visibility array of the output.  
\item {\ttfamily obj.\-I\-Blanking\-Off ()} -\/ Is there iblanking (point visibility) information in the file. If there is iblanking arrays, these will be read and assigned to the Point\-Visibility array of the output.  
\item {\ttfamily obj.\-Set\-Two\-Dimensional\-Geometry (int )} -\/ If only two-\/dimensional data was written to the file, turn this on.  
\item {\ttfamily int = obj.\-Get\-Two\-Dimensional\-Geometry ()} -\/ If only two-\/dimensional data was written to the file, turn this on.  
\item {\ttfamily obj.\-Two\-Dimensional\-Geometry\-On ()} -\/ If only two-\/dimensional data was written to the file, turn this on.  
\item {\ttfamily obj.\-Two\-Dimensional\-Geometry\-Off ()} -\/ If only two-\/dimensional data was written to the file, turn this on.  
\item {\ttfamily obj.\-Set\-Force\-Read (int )} -\/ Try to read a binary file even if the file length seems to be inconsistent with the header information. Use this with caution, if the file length is not the same as calculated from the header. either the file is corrupt or the settings are wrong.  
\item {\ttfamily int = obj.\-Get\-Force\-Read ()} -\/ Try to read a binary file even if the file length seems to be inconsistent with the header information. Use this with caution, if the file length is not the same as calculated from the header. either the file is corrupt or the settings are wrong.  
\item {\ttfamily obj.\-Force\-Read\-On ()} -\/ Try to read a binary file even if the file length seems to be inconsistent with the header information. Use this with caution, if the file length is not the same as calculated from the header. either the file is corrupt or the settings are wrong.  
\item {\ttfamily obj.\-Force\-Read\-Off ()} -\/ Try to read a binary file even if the file length seems to be inconsistent with the header information. Use this with caution, if the file length is not the same as calculated from the header. either the file is corrupt or the settings are wrong.  
\item {\ttfamily obj.\-Set\-Byte\-Order\-To\-Big\-Endian ()} -\/ Set the byte order of the file (remember, more Unix workstations write big endian whereas P\-Cs write little endian). Default is big endian (since most older P\-L\-O\-T3\-D files were written by workstations).  
\item {\ttfamily obj.\-Set\-Byte\-Order\-To\-Little\-Endian ()} -\/ Set the byte order of the file (remember, more Unix workstations write big endian whereas P\-Cs write little endian). Default is big endian (since most older P\-L\-O\-T3\-D files were written by workstations).  
\item {\ttfamily obj.\-Set\-Byte\-Order (int )} -\/ Set the byte order of the file (remember, more Unix workstations write big endian whereas P\-Cs write little endian). Default is big endian (since most older P\-L\-O\-T3\-D files were written by workstations).  
\item {\ttfamily int = obj.\-Get\-Byte\-Order ()} -\/ Set the byte order of the file (remember, more Unix workstations write big endian whereas P\-Cs write little endian). Default is big endian (since most older P\-L\-O\-T3\-D files were written by workstations).  
\item {\ttfamily string = obj.\-Get\-Byte\-Order\-As\-String ()} -\/ Set the byte order of the file (remember, more Unix workstations write big endian whereas P\-Cs write little endian). Default is big endian (since most older P\-L\-O\-T3\-D files were written by workstations).  
\item {\ttfamily obj.\-Set\-R (double )} -\/ Set/\-Get the gas constant. Default is 1.\-0.  
\item {\ttfamily double = obj.\-Get\-R ()} -\/ Set/\-Get the gas constant. Default is 1.\-0.  
\item {\ttfamily obj.\-Set\-Gamma (double )} -\/ Set/\-Get the ratio of specific heats. Default is 1.\-4.  
\item {\ttfamily double = obj.\-Get\-Gamma ()} -\/ Set/\-Get the ratio of specific heats. Default is 1.\-4.  
\item {\ttfamily obj.\-Set\-Uvinf (double )} -\/ Set/\-Get the x-\/component of the free-\/stream velocity. Default is 1.\-0.  
\item {\ttfamily double = obj.\-Get\-Uvinf ()} -\/ Set/\-Get the x-\/component of the free-\/stream velocity. Default is 1.\-0.  
\item {\ttfamily obj.\-Set\-Vvinf (double )} -\/ Set/\-Get the y-\/component of the free-\/stream velocity. Default is 1.\-0.  
\item {\ttfamily double = obj.\-Get\-Vvinf ()} -\/ Set/\-Get the y-\/component of the free-\/stream velocity. Default is 1.\-0.  
\item {\ttfamily obj.\-Set\-Wvinf (double )} -\/ Set/\-Get the z-\/component of the free-\/stream velocity. Default is 1.\-0.  
\item {\ttfamily double = obj.\-Get\-Wvinf ()} -\/ Set/\-Get the z-\/component of the free-\/stream velocity. Default is 1.\-0.  
\item {\ttfamily obj.\-Set\-Scalar\-Function\-Number (int num)} -\/ Specify the scalar function to extract. If ==(-\/1), then no scalar function is extracted.  
\item {\ttfamily int = obj.\-Get\-Scalar\-Function\-Number ()} -\/ Specify the scalar function to extract. If ==(-\/1), then no scalar function is extracted.  
\item {\ttfamily obj.\-Set\-Vector\-Function\-Number (int num)} -\/ Specify the vector function to extract. If ==(-\/1), then no vector function is extracted.  
\item {\ttfamily int = obj.\-Get\-Vector\-Function\-Number ()} -\/ Specify the vector function to extract. If ==(-\/1), then no vector function is extracted.  
\item {\ttfamily obj.\-Add\-Function (int function\-Number)} -\/ Specify additional functions to read. These are placed into the point data as data arrays. Later on they can be used by labeling them as scalars, etc.  
\item {\ttfamily obj.\-Remove\-Function (int )} -\/ Specify additional functions to read. These are placed into the point data as data arrays. Later on they can be used by labeling them as scalars, etc.  
\item {\ttfamily obj.\-Remove\-All\-Functions ()} -\/ Specify additional functions to read. These are placed into the point data as data arrays. Later on they can be used by labeling them as scalars, etc.  
\item {\ttfamily int = obj.\-Can\-Read\-Binary\-File (string fname)} -\/ Return 1 if the reader can read the given file name. Only meaningful for binary files.  
\end{DoxyItemize}\hypertarget{vtkio_vtknetcdfcfreader}{}\section{vtk\-Net\-C\-D\-F\-C\-F\-Reader}\label{vtkio_vtknetcdfcfreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Reads net\-C\-D\-F files that follow the C\-F convention. Details on this convention can be found at \href{http://cf-pcmdi.llnl.gov/}{\tt http\-://cf-\/pcmdi.\-llnl.\-gov/}.

To create an instance of class vtk\-Net\-C\-D\-F\-C\-F\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkNetCDFCFReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Net\-C\-D\-F\-C\-F\-Reader 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\-Net\-C\-D\-F\-C\-F\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Net\-C\-D\-F\-C\-F\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Net\-C\-D\-F\-C\-F\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Spherical\-Coordinates ()} -\/ If on (the default), then 3\-D data with latitude/longitude dimensions will be read in as curvilinear data shaped like spherical coordinates. If false, then the data will always be read in Cartesian coordinates.  
\item {\ttfamily obj.\-Set\-Spherical\-Coordinates (int )} -\/ If on (the default), then 3\-D data with latitude/longitude dimensions will be read in as curvilinear data shaped like spherical coordinates. If false, then the data will always be read in Cartesian coordinates.  
\item {\ttfamily obj.\-Spherical\-Coordinates\-On ()} -\/ If on (the default), then 3\-D data with latitude/longitude dimensions will be read in as curvilinear data shaped like spherical coordinates. If false, then the data will always be read in Cartesian coordinates.  
\item {\ttfamily obj.\-Spherical\-Coordinates\-Off ()} -\/ If on (the default), then 3\-D data with latitude/longitude dimensions will be read in as curvilinear data shaped like spherical coordinates. If false, then the data will always be read in Cartesian coordinates.  
\item {\ttfamily double = obj.\-Get\-Vertical\-Scale ()} -\/ The scale and bias of the vertical component of spherical coordinates. It is common to write the vertical component with respect to something other than the center of the sphere (for example, the surface). In this case, it might be necessary to scale and/or bias the vertical height. The height will become height$\ast$scale + bias. Keep in mind that if the positive attribute of the vertical dimension is down, then the height is negated. By default the scale is 1 and the bias is 0 (that is, no change). The scaling will be adjusted if it results in invalid (negative) vertical values.  
\item {\ttfamily obj.\-Set\-Vertical\-Scale (double )} -\/ The scale and bias of the vertical component of spherical coordinates. It is common to write the vertical component with respect to something other than the center of the sphere (for example, the surface). In this case, it might be necessary to scale and/or bias the vertical height. The height will become height$\ast$scale + bias. Keep in mind that if the positive attribute of the vertical dimension is down, then the height is negated. By default the scale is 1 and the bias is 0 (that is, no change). The scaling will be adjusted if it results in invalid (negative) vertical values.  
\item {\ttfamily double = obj.\-Get\-Vertical\-Bias ()} -\/ The scale and bias of the vertical component of spherical coordinates. It is common to write the vertical component with respect to something other than the center of the sphere (for example, the surface). In this case, it might be necessary to scale and/or bias the vertical height. The height will become height$\ast$scale + bias. Keep in mind that if the positive attribute of the vertical dimension is down, then the height is negated. By default the scale is 1 and the bias is 0 (that is, no change). The scaling will be adjusted if it results in invalid (negative) vertical values.  
\item {\ttfamily obj.\-Set\-Vertical\-Bias (double )} -\/ The scale and bias of the vertical component of spherical coordinates. It is common to write the vertical component with respect to something other than the center of the sphere (for example, the surface). In this case, it might be necessary to scale and/or bias the vertical height. The height will become height$\ast$scale + bias. Keep in mind that if the positive attribute of the vertical dimension is down, then the height is negated. By default the scale is 1 and the bias is 0 (that is, no change). The scaling will be adjusted if it results in invalid (negative) vertical values.  
\end{DoxyItemize}\hypertarget{vtkio_vtknetcdfpopreader}{}\section{vtk\-Net\-C\-D\-F\-P\-O\-P\-Reader}\label{vtkio_vtknetcdfpopreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Net\-C\-D\-F\-P\-O\-P\-Reader is a source object that reads Net\-C\-D\-F files. It should be able to read most any Net\-C\-D\-F file that wants to output rectilinear grid

To create an instance of class vtk\-Net\-C\-D\-F\-P\-O\-P\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkNetCDFPOPReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Net\-C\-D\-F\-P\-O\-P\-Reader 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\-Net\-C\-D\-F\-P\-O\-P\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Net\-C\-D\-F\-P\-O\-P\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Net\-C\-D\-F\-P\-O\-P\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Filename (string )}  
\item {\ttfamily string = obj.\-Get\-Filename ()}  
\item {\ttfamily obj.\-Set\-Whole\-Extent (int , int , int , int , int , int )}  
\item {\ttfamily obj.\-Set\-Whole\-Extent (int a\mbox{[}6\mbox{]})}  
\item {\ttfamily int = obj. Get\-Whole\-Extent ()}  
\item {\ttfamily obj.\-Set\-Sub\-Extent (int , int , int , int , int , int )}  
\item {\ttfamily obj.\-Set\-Sub\-Extent (int a\mbox{[}6\mbox{]})}  
\item {\ttfamily int = obj. Get\-Sub\-Extent ()}  
\item {\ttfamily obj.\-Set\-Origin (double , double , double )}  
\item {\ttfamily obj.\-Set\-Origin (double a\mbox{[}3\mbox{]})}  
\item {\ttfamily double = obj. Get\-Origin ()}  
\item {\ttfamily obj.\-Set\-Spacing (double , double , double )}  
\item {\ttfamily obj.\-Set\-Spacing (double a\mbox{[}3\mbox{]})}  
\item {\ttfamily double = obj. Get\-Spacing ()}  
\item {\ttfamily obj.\-Set\-Stride (int , int , int )}  
\item {\ttfamily obj.\-Set\-Stride (int a\mbox{[}3\mbox{]})}  
\item {\ttfamily int = obj. Get\-Stride ()}  
\item {\ttfamily obj.\-Set\-Block\-Read\-Size (int )}  
\item {\ttfamily int = obj.\-Get\-Block\-Read\-Size ()}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Variable\-Arrays ()} -\/ Variable array selection.  
\item {\ttfamily string = obj.\-Get\-Variable\-Array\-Name (int idx)} -\/ Variable array selection.  
\item {\ttfamily int = obj.\-Get\-Variable\-Array\-Status (string name)} -\/ Variable array selection.  
\item {\ttfamily obj.\-Set\-Variable\-Array\-Status (string name, int status)} -\/ Variable array selection.  
\end{DoxyItemize}\hypertarget{vtkio_vtknetcdfreader}{}\section{vtk\-Net\-C\-D\-F\-Reader}\label{vtkio_vtknetcdfreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
A superclass for reading net\-C\-D\-F files. Subclass add conventions to the reader. This class just outputs data into a multi block data set with a vtk\-Image\-Data at each block. A block is created for each variable except that variables with matching dimensions will be placed in the same block.

To create an instance of class vtk\-Net\-C\-D\-F\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkNetCDFReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Net\-C\-D\-F\-Reader 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\-Net\-C\-D\-F\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Net\-C\-D\-F\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Net\-C\-D\-F\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string filename)}  
\item {\ttfamily string = obj.\-Get\-File\-Name ()}  
\item {\ttfamily int = obj.\-Update\-Meta\-Data ()} -\/ Update the meta data from the current file. Automatically called during the Request\-Information pipeline update stage.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Variable\-Arrays ()} -\/ Variable array selection.  
\item {\ttfamily string = obj.\-Get\-Variable\-Array\-Name (int idx)} -\/ Variable array selection.  
\item {\ttfamily int = obj.\-Get\-Variable\-Array\-Status (string name)} -\/ Variable array selection.  
\item {\ttfamily obj.\-Set\-Variable\-Array\-Status (string name, int status)} -\/ Variable array selection.  
\item {\ttfamily vtk\-String\-Array = obj.\-Get\-Variable\-Dimensions ()} -\/ Returns an array with string encodings for the dimensions used in each of the variables. The indices in the returned array correspond to those used in the Get\-Variable\-Array\-Name method. Two arrays with the same dimensions will have the same encoded string returned by this method.  
\item {\ttfamily obj.\-Set\-Dimensions (string dimensions)} -\/ Loads the grid with the given dimensions. The dimensions are encoded in a string that conforms to the same format as returned by Get\-Variable\-Dimensions and Get\-All\-Dimensions. This method is really a convenience method for Set\-Variable\-Array\-Status. It turns on all variables that have the given dimensions and turns off all other variables.  
\item {\ttfamily vtk\-String\-Array = obj.\-Get\-All\-Dimensions ()} -\/ Returns an array with string encodings for the dimension combinations used in the variables. The result is the same as Get\-Variable\-Dimensions except that each entry in the array is unique (a set of dimensions is only given once even if it occurs for multiple variables) and the order is meaningless.  
\item {\ttfamily int = obj.\-Get\-Replace\-Fill\-Value\-With\-Nan ()} -\/ If on, any float or double variable read that has a \-\_\-\-Fill\-Value attribute will have that fill value replaced with a not-\/a-\/number (Na\-N) value. The advantage of setting these to Na\-N values is that, if implemented properly by the system and careful math operations are used, they can implicitly be ignored by calculations like finding the range of the values. That said, this option should be used with caution as V\-T\-K does not fully support Na\-N values and therefore odd calculations may occur. By default this is off.  
\item {\ttfamily obj.\-Set\-Replace\-Fill\-Value\-With\-Nan (int )} -\/ If on, any float or double variable read that has a \-\_\-\-Fill\-Value attribute will have that fill value replaced with a not-\/a-\/number (Na\-N) value. The advantage of setting these to Na\-N values is that, if implemented properly by the system and careful math operations are used, they can implicitly be ignored by calculations like finding the range of the values. That said, this option should be used with caution as V\-T\-K does not fully support Na\-N values and therefore odd calculations may occur. By default this is off.  
\item {\ttfamily obj.\-Replace\-Fill\-Value\-With\-Nan\-On ()} -\/ If on, any float or double variable read that has a \-\_\-\-Fill\-Value attribute will have that fill value replaced with a not-\/a-\/number (Na\-N) value. The advantage of setting these to Na\-N values is that, if implemented properly by the system and careful math operations are used, they can implicitly be ignored by calculations like finding the range of the values. That said, this option should be used with caution as V\-T\-K does not fully support Na\-N values and therefore odd calculations may occur. By default this is off.  
\item {\ttfamily obj.\-Replace\-Fill\-Value\-With\-Nan\-Off ()} -\/ If on, any float or double variable read that has a \-\_\-\-Fill\-Value attribute will have that fill value replaced with a not-\/a-\/number (Na\-N) value. The advantage of setting these to Na\-N values is that, if implemented properly by the system and careful math operations are used, they can implicitly be ignored by calculations like finding the range of the values. That said, this option should be used with caution as V\-T\-K does not fully support Na\-N values and therefore odd calculations may occur. By default this is off.  
\end{DoxyItemize}\hypertarget{vtkio_vtkobjreader}{}\section{vtk\-O\-B\-J\-Reader}\label{vtkio_vtkobjreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-O\-B\-J\-Reader is a source object that reads Wavefront .obj files. The output of this source object is polygonal data.

To create an instance of class vtk\-O\-B\-J\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOBJReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-O\-B\-J\-Reader 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\-O\-B\-J\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-O\-B\-J\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-O\-B\-J\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify file name of Wavefront .obj file.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify file name of Wavefront .obj file.  
\end{DoxyItemize}\hypertarget{vtkio_vtkopenfoamreader}{}\section{vtk\-Open\-F\-O\-A\-M\-Reader}\label{vtkio_vtkopenfoamreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Open\-F\-O\-A\-M\-Reader creates a multiblock dataset. It reads mesh information and time dependent data. The poly\-Mesh folders contain mesh information. The time folders contain transient data for the cells. Each folder can contain any number of data files.

To create an instance of class vtk\-Open\-F\-O\-A\-M\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenFOAMReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-F\-O\-A\-M\-Reader 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\-Open\-F\-O\-A\-M\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-F\-O\-A\-M\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-F\-O\-A\-M\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Can\-Read\-File (string )} -\/ Determine if the file can be readed with this reader.  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Set/\-Get the filename.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Set/\-Get the filename.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Cell\-Arrays (void )} -\/ Get/\-Set whether the cell array with the given name is to be read.  
\item {\ttfamily int = obj.\-Get\-Cell\-Array\-Status (string name)} -\/ Get/\-Set whether the cell array with the given name is to be read.  
\item {\ttfamily obj.\-Set\-Cell\-Array\-Status (string name, int status)} -\/ Get the name of the cell array with the given index in the input.  
\item {\ttfamily string = obj.\-Get\-Cell\-Array\-Name (int index)} -\/ Turn on/off all cell arrays.  
\item {\ttfamily obj.\-Disable\-All\-Cell\-Arrays ()} -\/ Turn on/off all cell arrays.  
\item {\ttfamily obj.\-Enable\-All\-Cell\-Arrays ()} -\/ Get the number of point arrays available in the input.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Point\-Arrays (void )} -\/ Get/\-Set whether the point array with the given name is to be read.  
\item {\ttfamily int = obj.\-Get\-Point\-Array\-Status (string name)} -\/ Get/\-Set whether the point array with the given name is to be read.  
\item {\ttfamily obj.\-Set\-Point\-Array\-Status (string name, int status)} -\/ Get the name of the point array with the given index in the input.  
\item {\ttfamily string = obj.\-Get\-Point\-Array\-Name (int index)} -\/ Turn on/off all point arrays.  
\item {\ttfamily obj.\-Disable\-All\-Point\-Arrays ()} -\/ Turn on/off all point arrays.  
\item {\ttfamily obj.\-Enable\-All\-Point\-Arrays ()} -\/ Get the number of Lagrangian arrays available in the input.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Lagrangian\-Arrays (void )} -\/ Get/\-Set whether the Lagrangian array with the given name is to be read.  
\item {\ttfamily int = obj.\-Get\-Lagrangian\-Array\-Status (string name)} -\/ Get/\-Set whether the Lagrangian array with the given name is to be read.  
\item {\ttfamily obj.\-Set\-Lagrangian\-Array\-Status (string name, int status)} -\/ Get the name of the Lagrangian array with the given index in the input.  
\item {\ttfamily string = obj.\-Get\-Lagrangian\-Array\-Name (int index)} -\/ Turn on/off all Lagrangian arrays.  
\item {\ttfamily obj.\-Disable\-All\-Lagrangian\-Arrays ()} -\/ Turn on/off all Lagrangian arrays.  
\item {\ttfamily obj.\-Enable\-All\-Lagrangian\-Arrays ()} -\/ Get the number of Patches (inlcuding Internal Mesh) available in the input.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Patch\-Arrays (void )} -\/ Get/\-Set whether the Patch with the given name is to be read.  
\item {\ttfamily int = obj.\-Get\-Patch\-Array\-Status (string name)} -\/ Get/\-Set whether the Patch with the given name is to be read.  
\item {\ttfamily obj.\-Set\-Patch\-Array\-Status (string name, int status)} -\/ Get the name of the Patch with the given index in the input.  
\item {\ttfamily string = obj.\-Get\-Patch\-Array\-Name (int index)} -\/ Turn on/off all Patches including the Internal Mesh.  
\item {\ttfamily obj.\-Disable\-All\-Patch\-Arrays ()} -\/ Turn on/off all Patches including the Internal Mesh.  
\item {\ttfamily obj.\-Enable\-All\-Patch\-Arrays ()} -\/ Set/\-Get whether to create cell-\/to-\/point translated data for cell-\/type data  
\item {\ttfamily obj.\-Set\-Create\-Cell\-To\-Point (int )} -\/ Set/\-Get whether to create cell-\/to-\/point translated data for cell-\/type data  
\item {\ttfamily int = obj.\-Get\-Create\-Cell\-To\-Point ()} -\/ Set/\-Get whether to create cell-\/to-\/point translated data for cell-\/type data  
\item {\ttfamily obj.\-Create\-Cell\-To\-Point\-On ()} -\/ Set/\-Get whether to create cell-\/to-\/point translated data for cell-\/type data  
\item {\ttfamily obj.\-Create\-Cell\-To\-Point\-Off ()} -\/ Set/\-Get whether to create cell-\/to-\/point translated data for cell-\/type data  
\item {\ttfamily obj.\-Set\-Cache\-Mesh (int )} -\/ Set/\-Get whether mesh is to be cached.  
\item {\ttfamily int = obj.\-Get\-Cache\-Mesh ()} -\/ Set/\-Get whether mesh is to be cached.  
\item {\ttfamily obj.\-Cache\-Mesh\-On ()} -\/ Set/\-Get whether mesh is to be cached.  
\item {\ttfamily obj.\-Cache\-Mesh\-Off ()} -\/ Set/\-Get whether mesh is to be cached.  
\item {\ttfamily obj.\-Set\-Decompose\-Polyhedra (int )} -\/ Set/\-Get whether polyhedra are to be decomposed.  
\item {\ttfamily int = obj.\-Get\-Decompose\-Polyhedra ()} -\/ Set/\-Get whether polyhedra are to be decomposed.  
\item {\ttfamily obj.\-Decompose\-Polyhedra\-On ()} -\/ Set/\-Get whether polyhedra are to be decomposed.  
\item {\ttfamily obj.\-Decompose\-Polyhedra\-Off ()} -\/ Set/\-Get whether polyhedra are to be decomposed.  
\item {\ttfamily obj.\-Set\-Positions\-Is\-In13\-Format (int )} -\/ Set/\-Get whether the lagrangian/positions is in O\-F 1.\-3 format  
\item {\ttfamily int = obj.\-Get\-Positions\-Is\-In13\-Format ()} -\/ Set/\-Get whether the lagrangian/positions is in O\-F 1.\-3 format  
\item {\ttfamily obj.\-Positions\-Is\-In13\-Format\-On ()} -\/ Set/\-Get whether the lagrangian/positions is in O\-F 1.\-3 format  
\item {\ttfamily obj.\-Positions\-Is\-In13\-Format\-Off ()} -\/ Set/\-Get whether the lagrangian/positions is in O\-F 1.\-3 format  
\item {\ttfamily obj.\-Set\-List\-Time\-Steps\-By\-Control\-Dict (int )} -\/ Determine if time directories are to be listed according to control\-Dict  
\item {\ttfamily int = obj.\-Get\-List\-Time\-Steps\-By\-Control\-Dict ()} -\/ Determine if time directories are to be listed according to control\-Dict  
\item {\ttfamily obj.\-List\-Time\-Steps\-By\-Control\-Dict\-On ()} -\/ Determine if time directories are to be listed according to control\-Dict  
\item {\ttfamily obj.\-List\-Time\-Steps\-By\-Control\-Dict\-Off ()} -\/ Determine if time directories are to be listed according to control\-Dict  
\item {\ttfamily obj.\-Set\-Add\-Dimensions\-To\-Array\-Names (int )} -\/ Add dimensions to array names  
\item {\ttfamily int = obj.\-Get\-Add\-Dimensions\-To\-Array\-Names ()} -\/ Add dimensions to array names  
\item {\ttfamily obj.\-Add\-Dimensions\-To\-Array\-Names\-On ()} -\/ Add dimensions to array names  
\item {\ttfamily obj.\-Add\-Dimensions\-To\-Array\-Names\-Off ()} -\/ Add dimensions to array names  
\item {\ttfamily obj.\-Set\-Read\-Zones (int )} -\/ Set/\-Get whether zones will be read.  
\item {\ttfamily int = obj.\-Get\-Read\-Zones ()} -\/ Set/\-Get whether zones will be read.  
\item {\ttfamily obj.\-Read\-Zones\-On ()} -\/ Set/\-Get whether zones will be read.  
\item {\ttfamily obj.\-Read\-Zones\-Off ()} -\/ Set/\-Get whether zones will be read.  
\item {\ttfamily obj.\-Set\-Refresh ()}  
\item {\ttfamily obj.\-Set\-Parent (vtk\-Open\-F\-O\-A\-M\-Reader parent)}  
\item {\ttfamily bool = obj.\-Set\-Time\-Value (double )}  
\item {\ttfamily vtk\-Double\-Array = obj.\-Get\-Time\-Values ()}  
\item {\ttfamily int = obj.\-Make\-Meta\-Data\-At\-Time\-Step (bool )}  
\end{DoxyItemize}\hypertarget{vtkio_vtkoutputstream}{}\section{vtk\-Output\-Stream}\label{vtkio_vtkoutputstream}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Output\-Stream provides a V\-T\-K-\/style interface wrapping around a standard output stream. The access methods are virtual so that subclasses can transparently provide encoding of the output. Data lengths for Write calls refer to the length of the data in memory. The actual length in the stream may differ for subclasses that implement an encoding scheme.

To create an instance of class vtk\-Output\-Stream, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOutputStream
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Output\-Stream 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\-Stream class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Output\-Stream = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Output\-Stream = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Start\-Writing ()} -\/ Called after the stream position has been set by the caller, but before any Write calls. The stream position should not be adjusted by the caller until after an End\-Writing call.  
\item {\ttfamily int = obj.\-Write (string data, long length)} -\/ Write output data of the given length.  
\item {\ttfamily int = obj.\-Write (string data, long length)} -\/ Write output data of the given length.  
\item {\ttfamily int = obj.\-End\-Writing ()} -\/ Called after all desired calls to Write have been made. After this call, the caller is free to change the position of the stream. Additional writes should not be done until after another call to Start\-Writing.  
\end{DoxyItemize}\hypertarget{vtkio_vtkparticlereader}{}\section{vtk\-Particle\-Reader}\label{vtkio_vtkparticlereader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Particle\-Reader reads either a binary or a text file of particles. Each particle can have associated with it an optional scalar value. So the format is\-: x, y, z, scalar (all floats or doubles). The text file can consist of a comma delimited set of values. In most cases vtk\-Particle\-Reader can automatically determine whether the file is text or binary. The data can be either float or double. Progress updates are provided. With respect to binary files, random access into the file to read pieces is supported.

To create an instance of class vtk\-Particle\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkParticleReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Particle\-Reader 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\-Particle\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Particle\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Particle\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify file name.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify file name.  
\item {\ttfamily obj.\-Set\-Data\-Byte\-Order\-To\-Big\-Endian ()} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian. Not used when reading text files.  
\item {\ttfamily obj.\-Set\-Data\-Byte\-Order\-To\-Little\-Endian ()} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian. Not used when reading text files.  
\item {\ttfamily int = obj.\-Get\-Data\-Byte\-Order ()} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian. Not used when reading text files.  
\item {\ttfamily obj.\-Set\-Data\-Byte\-Order (int )} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian. Not used when reading text files.  
\item {\ttfamily string = obj.\-Get\-Data\-Byte\-Order\-As\-String ()} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian. Not used when reading text files.  
\item {\ttfamily obj.\-Set\-Swap\-Bytes (int )} -\/ Set/\-Get the byte swapping to explicitly swap the bytes of a file. Not used when reading text files.  
\item {\ttfamily int = obj.\-Get\-Swap\-Bytes ()} -\/ Set/\-Get the byte swapping to explicitly swap the bytes of a file. Not used when reading text files.  
\item {\ttfamily obj.\-Swap\-Bytes\-On ()} -\/ Set/\-Get the byte swapping to explicitly swap the bytes of a file. Not used when reading text files.  
\item {\ttfamily obj.\-Swap\-Bytes\-Off ()} -\/ Set/\-Get the byte swapping to explicitly swap the bytes of a file. Not used when reading text files.  
\item {\ttfamily obj.\-Set\-Has\-Scalar (int )} -\/ Default\-: 1. If 1 then each particle has a value associated with it.  
\item {\ttfamily int = obj.\-Get\-Has\-Scalar ()} -\/ Default\-: 1. If 1 then each particle has a value associated with it.  
\item {\ttfamily obj.\-Has\-Scalar\-On ()} -\/ Default\-: 1. If 1 then each particle has a value associated with it.  
\item {\ttfamily obj.\-Has\-Scalar\-Off ()} -\/ Default\-: 1. If 1 then each particle has a value associated with it.  
\item {\ttfamily obj.\-Set\-File\-Type (int )} -\/ Get/\-Set the file type. The options are\-:
\begin{DoxyItemize}
\item F\-I\-L\-E\-\_\-\-T\-Y\-P\-E\-\_\-\-I\-S\-\_\-\-U\-N\-K\-N\-O\-W\-N (default) the class will attempt to determine the file type. If this fails then you should set the file type yourself.
\item F\-I\-L\-E\-\_\-\-T\-Y\-P\-E\-\_\-\-I\-S\-\_\-\-T\-E\-X\-T the file type is text.
\item F\-I\-L\-E\-\_\-\-T\-Y\-P\-E\-\_\-\-I\-S\-\_\-\-B\-I\-N\-A\-R\-Y the file type is binary.  
\end{DoxyItemize}
\item {\ttfamily int = obj.\-Get\-File\-Type\-Min\-Value ()} -\/ Get/\-Set the file type. The options are\-:
\begin{DoxyItemize}
\item F\-I\-L\-E\-\_\-\-T\-Y\-P\-E\-\_\-\-I\-S\-\_\-\-U\-N\-K\-N\-O\-W\-N (default) the class will attempt to determine the file type. If this fails then you should set the file type yourself.
\item F\-I\-L\-E\-\_\-\-T\-Y\-P\-E\-\_\-\-I\-S\-\_\-\-T\-E\-X\-T the file type is text.
\item F\-I\-L\-E\-\_\-\-T\-Y\-P\-E\-\_\-\-I\-S\-\_\-\-B\-I\-N\-A\-R\-Y the file type is binary.  
\end{DoxyItemize}
\item {\ttfamily int = obj.\-Get\-File\-Type\-Max\-Value ()} -\/ Get/\-Set the file type. The options are\-:
\begin{DoxyItemize}
\item F\-I\-L\-E\-\_\-\-T\-Y\-P\-E\-\_\-\-I\-S\-\_\-\-U\-N\-K\-N\-O\-W\-N (default) the class will attempt to determine the file type. If this fails then you should set the file type yourself.
\item F\-I\-L\-E\-\_\-\-T\-Y\-P\-E\-\_\-\-I\-S\-\_\-\-T\-E\-X\-T the file type is text.
\item F\-I\-L\-E\-\_\-\-T\-Y\-P\-E\-\_\-\-I\-S\-\_\-\-B\-I\-N\-A\-R\-Y the file type is binary.  
\end{DoxyItemize}
\item {\ttfamily int = obj.\-Get\-File\-Type ()} -\/ Get/\-Set the file type. The options are\-:
\begin{DoxyItemize}
\item F\-I\-L\-E\-\_\-\-T\-Y\-P\-E\-\_\-\-I\-S\-\_\-\-U\-N\-K\-N\-O\-W\-N (default) the class will attempt to determine the file type. If this fails then you should set the file type yourself.
\item F\-I\-L\-E\-\_\-\-T\-Y\-P\-E\-\_\-\-I\-S\-\_\-\-T\-E\-X\-T the file type is text.
\item F\-I\-L\-E\-\_\-\-T\-Y\-P\-E\-\_\-\-I\-S\-\_\-\-B\-I\-N\-A\-R\-Y the file type is binary.  
\end{DoxyItemize}
\item {\ttfamily obj.\-Set\-File\-Type\-To\-Unknown ()} -\/ Get/\-Set the file type. The options are\-:
\begin{DoxyItemize}
\item F\-I\-L\-E\-\_\-\-T\-Y\-P\-E\-\_\-\-I\-S\-\_\-\-U\-N\-K\-N\-O\-W\-N (default) the class will attempt to determine the file type. If this fails then you should set the file type yourself.
\item F\-I\-L\-E\-\_\-\-T\-Y\-P\-E\-\_\-\-I\-S\-\_\-\-T\-E\-X\-T the file type is text.
\item F\-I\-L\-E\-\_\-\-T\-Y\-P\-E\-\_\-\-I\-S\-\_\-\-B\-I\-N\-A\-R\-Y the file type is binary.  
\end{DoxyItemize}
\item {\ttfamily obj.\-Set\-File\-Type\-To\-Text ()} -\/ Get/\-Set the file type. The options are\-:
\begin{DoxyItemize}
\item F\-I\-L\-E\-\_\-\-T\-Y\-P\-E\-\_\-\-I\-S\-\_\-\-U\-N\-K\-N\-O\-W\-N (default) the class will attempt to determine the file type. If this fails then you should set the file type yourself.
\item F\-I\-L\-E\-\_\-\-T\-Y\-P\-E\-\_\-\-I\-S\-\_\-\-T\-E\-X\-T the file type is text.
\item F\-I\-L\-E\-\_\-\-T\-Y\-P\-E\-\_\-\-I\-S\-\_\-\-B\-I\-N\-A\-R\-Y the file type is binary.  
\end{DoxyItemize}
\item {\ttfamily obj.\-Set\-File\-Type\-To\-Binary ()} -\/ Get/\-Set the data type. The options are\-:
\begin{DoxyItemize}
\item V\-T\-K\-\_\-\-F\-L\-O\-A\-T (default) single precision floating point.
\item V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E double precision floating point.  
\end{DoxyItemize}
\item {\ttfamily obj.\-Set\-Data\-Type (int )} -\/ Get/\-Set the data type. The options are\-:
\begin{DoxyItemize}
\item V\-T\-K\-\_\-\-F\-L\-O\-A\-T (default) single precision floating point.
\item V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E double precision floating point.  
\end{DoxyItemize}
\item {\ttfamily int = obj.\-Get\-Data\-Type\-Min\-Value ()} -\/ Get/\-Set the data type. The options are\-:
\begin{DoxyItemize}
\item V\-T\-K\-\_\-\-F\-L\-O\-A\-T (default) single precision floating point.
\item V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E double precision floating point.  
\end{DoxyItemize}
\item {\ttfamily int = obj.\-Get\-Data\-Type\-Max\-Value ()} -\/ Get/\-Set the data type. The options are\-:
\begin{DoxyItemize}
\item V\-T\-K\-\_\-\-F\-L\-O\-A\-T (default) single precision floating point.
\item V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E double precision floating point.  
\end{DoxyItemize}
\item {\ttfamily int = obj.\-Get\-Data\-Type ()} -\/ Get/\-Set the data type. The options are\-:
\begin{DoxyItemize}
\item V\-T\-K\-\_\-\-F\-L\-O\-A\-T (default) single precision floating point.
\item V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E double precision floating point.  
\end{DoxyItemize}
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Float ()} -\/ Get/\-Set the data type. The options are\-:
\begin{DoxyItemize}
\item V\-T\-K\-\_\-\-F\-L\-O\-A\-T (default) single precision floating point.
\item V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E double precision floating point.  
\end{DoxyItemize}
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Double ()}  
\end{DoxyItemize}\hypertarget{vtkio_vtkpdbreader}{}\section{vtk\-P\-D\-B\-Reader}\label{vtkio_vtkpdbreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-P\-D\-B\-Reader is a source object that reads Molecule files The File\-Name must be specified

.S\-E\-C\-T\-I\-O\-N Thanks Dr. Jean M. Favre who developed and contributed this class

To create an instance of class vtk\-P\-D\-B\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPDBReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-P\-D\-B\-Reader 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\-P\-D\-B\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-P\-D\-B\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-P\-D\-B\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkplot3dreader}{}\section{vtk\-P\-L\-O\-T3\-D\-Reader}\label{vtkio_vtkplot3dreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-P\-L\-O\-T3\-D\-Reader is a reader object that reads P\-L\-O\-T3\-D formatted files and generates structured grid(s) on output. P\-L\-O\-T3\-D is a computer graphics program designed to visualize the grids and solutions of computational fluid dynamics. Please see the \char`\"{}\-P\-L\-O\-T3\-D User's Manual\char`\"{} available from N\-A\-S\-A Ames Research Center, Moffett Field C\-A.

P\-L\-O\-T3\-D files consist of a grid file (also known as X\-Y\-Z file), an optional solution file (also known as a Q file), and an optional function file that contains user created data (currently unsupported). The Q file contains solution information as follows\-: the four parameters free stream mach number (Fsmach), angle of attack (Alpha), Reynolds number (Re), and total integration time (Time). This information is stored in an array called Properties in the Field\-Data of each output (tuple 0\-: fsmach, tuple 1\-: alpha, tuple 2\-: re, tuple 3\-: time). In addition, the solution file contains the flow density (scalar), flow momentum (vector), and flow energy (scalar).

The reader can generate additional scalars and vectors (or \char`\"{}functions\char`\"{}) from this information. To use vtk\-P\-L\-O\-T3\-D\-Reader, you must specify the particular function number for the scalar and vector you want to visualize. This implementation of the reader provides the following functions. The scalar functions are\-: -\/1 -\/ don't read or compute any scalars 100 -\/ density 110 -\/ pressure 120 -\/ temperature 130 -\/ enthalpy 140 -\/ internal energy 144 -\/ kinetic energy 153 -\/ velocity magnitude 163 -\/ stagnation energy 170 -\/ entropy 184 -\/ swirl.

The vector functions are\-: -\/1 -\/ don't read or compute any vectors 200 -\/ velocity 201 -\/ vorticity 202 -\/ momentum 210 -\/ pressure gradient.

(Other functions are described in the P\-L\-O\-T3\-D spec, but only those listed are implemented here.) Note that by default, this reader creates the density scalar (100) and momentum vector (202) as output. (These are just read in from the solution file.) Please note that the validity of computation is a function of this class's gas constants (R, Gamma) and the equations used. They may not be suitable for your computational domain.

Additionally, you can read other data and associate it as a vtk\-Data\-Array into the output's point attribute data. Use the method Add\-Function() to list all the functions that you'd like to read. Add\-Function() accepts an integer parameter that defines the function number.

To create an instance of class vtk\-P\-L\-O\-T3\-D\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPLOT3DReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-P\-L\-O\-T3\-D\-Reader 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\-P\-L\-O\-T3\-D\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-P\-L\-O\-T3\-D\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-P\-L\-O\-T3\-D\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string name)} -\/ Set/\-Get the P\-L\-O\-T3\-D geometry filename.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Set/\-Get the P\-L\-O\-T3\-D geometry filename.  
\item {\ttfamily obj.\-Set\-X\-Y\-Z\-File\-Name (string )} -\/ Set/\-Get the P\-L\-O\-T3\-D geometry filename.  
\item {\ttfamily string = obj.\-Get\-X\-Y\-Z\-File\-Name ()} -\/ Set/\-Get the P\-L\-O\-T3\-D geometry filename.  
\item {\ttfamily obj.\-Set\-Q\-File\-Name (string )} -\/ Set/\-Get the P\-L\-O\-T3\-D solution filename.  
\item {\ttfamily string = obj.\-Get\-Q\-File\-Name ()} -\/ Set/\-Get the P\-L\-O\-T3\-D solution filename.  
\item {\ttfamily obj.\-Set\-Function\-File\-Name (string )} -\/ Set/\-Get the P\-L\-O\-T3\-D Function Filename (optional)  
\item {\ttfamily string = obj.\-Get\-Function\-File\-Name ()} -\/ Set/\-Get the P\-L\-O\-T3\-D Function Filename (optional)  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Outputs ()} -\/ This returns the number of outputs this reader will produce. This number is equal to the number of grids in the current file. This method has to be called before getting any output if the number of outputs will be greater than 1 (the first output is always the same). Note that every time this method is invoked, the header file is opened and part of the header is read.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Grids ()} -\/ Replace an output.  
\item {\ttfamily obj.\-Set\-Output (int idx, vtk\-Structured\-Grid output)} -\/ Replace an output.  
\item {\ttfamily obj.\-Set\-Binary\-File (int )} -\/ Is the file to be read written in binary format (as opposed to ascii).  
\item {\ttfamily int = obj.\-Get\-Binary\-File ()} -\/ Is the file to be read written in binary format (as opposed to ascii).  
\item {\ttfamily obj.\-Binary\-File\-On ()} -\/ Is the file to be read written in binary format (as opposed to ascii).  
\item {\ttfamily obj.\-Binary\-File\-Off ()} -\/ Is the file to be read written in binary format (as opposed to ascii).  
\item {\ttfamily obj.\-Set\-Multi\-Grid (int )} -\/ Does the file to be read contain information about number of grids. In some P\-L\-O\-T3\-D files, the first value contains the number of grids (even if there is only 1). If reading such a file, set this to true.  
\item {\ttfamily int = obj.\-Get\-Multi\-Grid ()} -\/ Does the file to be read contain information about number of grids. In some P\-L\-O\-T3\-D files, the first value contains the number of grids (even if there is only 1). If reading such a file, set this to true.  
\item {\ttfamily obj.\-Multi\-Grid\-On ()} -\/ Does the file to be read contain information about number of grids. In some P\-L\-O\-T3\-D files, the first value contains the number of grids (even if there is only 1). If reading such a file, set this to true.  
\item {\ttfamily obj.\-Multi\-Grid\-Off ()} -\/ Does the file to be read contain information about number of grids. In some P\-L\-O\-T3\-D files, the first value contains the number of grids (even if there is only 1). If reading such a file, set this to true.  
\item {\ttfamily obj.\-Set\-Has\-Byte\-Count (int )} -\/ Were the arrays written with leading and trailing byte counts ? Usually, files written by a fortran program will contain these byte counts whereas the ones written by C/\-C++ won't.  
\item {\ttfamily int = obj.\-Get\-Has\-Byte\-Count ()} -\/ Were the arrays written with leading and trailing byte counts ? Usually, files written by a fortran program will contain these byte counts whereas the ones written by C/\-C++ won't.  
\item {\ttfamily obj.\-Has\-Byte\-Count\-On ()} -\/ Were the arrays written with leading and trailing byte counts ? Usually, files written by a fortran program will contain these byte counts whereas the ones written by C/\-C++ won't.  
\item {\ttfamily obj.\-Has\-Byte\-Count\-Off ()} -\/ Were the arrays written with leading and trailing byte counts ? Usually, files written by a fortran program will contain these byte counts whereas the ones written by C/\-C++ won't.  
\item {\ttfamily obj.\-Set\-I\-Blanking (int )} -\/ Is there iblanking (point visibility) information in the file. If there is iblanking arrays, these will be read and assigned to the Point\-Visibility array of the output.  
\item {\ttfamily int = obj.\-Get\-I\-Blanking ()} -\/ Is there iblanking (point visibility) information in the file. If there is iblanking arrays, these will be read and assigned to the Point\-Visibility array of the output.  
\item {\ttfamily obj.\-I\-Blanking\-On ()} -\/ Is there iblanking (point visibility) information in the file. If there is iblanking arrays, these will be read and assigned to the Point\-Visibility array of the output.  
\item {\ttfamily obj.\-I\-Blanking\-Off ()} -\/ Is there iblanking (point visibility) information in the file. If there is iblanking arrays, these will be read and assigned to the Point\-Visibility array of the output.  
\item {\ttfamily obj.\-Set\-Two\-Dimensional\-Geometry (int )} -\/ If only two-\/dimensional data was written to the file, turn this on.  
\item {\ttfamily int = obj.\-Get\-Two\-Dimensional\-Geometry ()} -\/ If only two-\/dimensional data was written to the file, turn this on.  
\item {\ttfamily obj.\-Two\-Dimensional\-Geometry\-On ()} -\/ If only two-\/dimensional data was written to the file, turn this on.  
\item {\ttfamily obj.\-Two\-Dimensional\-Geometry\-Off ()} -\/ If only two-\/dimensional data was written to the file, turn this on.  
\item {\ttfamily obj.\-Set\-Force\-Read (int )} -\/ Try to read a binary file even if the file length seems to be inconsistent with the header information. Use this with caution, if the file length is not the same as calculated from the header. either the file is corrupt or the settings are wrong.  
\item {\ttfamily int = obj.\-Get\-Force\-Read ()} -\/ Try to read a binary file even if the file length seems to be inconsistent with the header information. Use this with caution, if the file length is not the same as calculated from the header. either the file is corrupt or the settings are wrong.  
\item {\ttfamily obj.\-Force\-Read\-On ()} -\/ Try to read a binary file even if the file length seems to be inconsistent with the header information. Use this with caution, if the file length is not the same as calculated from the header. either the file is corrupt or the settings are wrong.  
\item {\ttfamily obj.\-Force\-Read\-Off ()} -\/ Try to read a binary file even if the file length seems to be inconsistent with the header information. Use this with caution, if the file length is not the same as calculated from the header. either the file is corrupt or the settings are wrong.  
\item {\ttfamily obj.\-Set\-Do\-Not\-Reduce\-Number\-Of\-Outputs (int )} -\/ If this is on, the reader will never reduce the number of outputs after reading a file with n grids and producing n outputs. If the file read afterwards contains fewer grids, the extra outputs will be empty. This option can be used by application which rely on the initial number of outputs not shrinking.  
\item {\ttfamily int = obj.\-Get\-Do\-Not\-Reduce\-Number\-Of\-Outputs ()} -\/ If this is on, the reader will never reduce the number of outputs after reading a file with n grids and producing n outputs. If the file read afterwards contains fewer grids, the extra outputs will be empty. This option can be used by application which rely on the initial number of outputs not shrinking.  
\item {\ttfamily obj.\-Do\-Not\-Reduce\-Number\-Of\-Outputs\-On ()} -\/ If this is on, the reader will never reduce the number of outputs after reading a file with n grids and producing n outputs. If the file read afterwards contains fewer grids, the extra outputs will be empty. This option can be used by application which rely on the initial number of outputs not shrinking.  
\item {\ttfamily obj.\-Do\-Not\-Reduce\-Number\-Of\-Outputs\-Off ()} -\/ If this is on, the reader will never reduce the number of outputs after reading a file with n grids and producing n outputs. If the file read afterwards contains fewer grids, the extra outputs will be empty. This option can be used by application which rely on the initial number of outputs not shrinking.  
\item {\ttfamily obj.\-Set\-Byte\-Order\-To\-Big\-Endian ()} -\/ Set the byte order of the file (remember, more Unix workstations write big endian whereas P\-Cs write little endian). Default is big endian (since most older P\-L\-O\-T3\-D files were written by workstations).  
\item {\ttfamily obj.\-Set\-Byte\-Order\-To\-Little\-Endian ()} -\/ Set the byte order of the file (remember, more Unix workstations write big endian whereas P\-Cs write little endian). Default is big endian (since most older P\-L\-O\-T3\-D files were written by workstations).  
\item {\ttfamily obj.\-Set\-Byte\-Order (int )} -\/ Set the byte order of the file (remember, more Unix workstations write big endian whereas P\-Cs write little endian). Default is big endian (since most older P\-L\-O\-T3\-D files were written by workstations).  
\item {\ttfamily int = obj.\-Get\-Byte\-Order ()} -\/ Set the byte order of the file (remember, more Unix workstations write big endian whereas P\-Cs write little endian). Default is big endian (since most older P\-L\-O\-T3\-D files were written by workstations).  
\item {\ttfamily string = obj.\-Get\-Byte\-Order\-As\-String ()} -\/ Set the byte order of the file (remember, more Unix workstations write big endian whereas P\-Cs write little endian). Default is big endian (since most older P\-L\-O\-T3\-D files were written by workstations).  
\item {\ttfamily obj.\-Set\-R (double )} -\/ Set/\-Get the gas constant. Default is 1.\-0.  
\item {\ttfamily double = obj.\-Get\-R ()} -\/ Set/\-Get the gas constant. Default is 1.\-0.  
\item {\ttfamily obj.\-Set\-Gamma (double )} -\/ Set/\-Get the ratio of specific heats. Default is 1.\-4.  
\item {\ttfamily double = obj.\-Get\-Gamma ()} -\/ Set/\-Get the ratio of specific heats. Default is 1.\-4.  
\item {\ttfamily obj.\-Set\-Uvinf (double )} -\/ Set/\-Get the x-\/component of the free-\/stream velocity. Default is 1.\-0.  
\item {\ttfamily double = obj.\-Get\-Uvinf ()} -\/ Set/\-Get the x-\/component of the free-\/stream velocity. Default is 1.\-0.  
\item {\ttfamily obj.\-Set\-Vvinf (double )} -\/ Set/\-Get the y-\/component of the free-\/stream velocity. Default is 1.\-0.  
\item {\ttfamily double = obj.\-Get\-Vvinf ()} -\/ Set/\-Get the y-\/component of the free-\/stream velocity. Default is 1.\-0.  
\item {\ttfamily obj.\-Set\-Wvinf (double )} -\/ Set/\-Get the z-\/component of the free-\/stream velocity. Default is 1.\-0.  
\item {\ttfamily double = obj.\-Get\-Wvinf ()} -\/ Set/\-Get the z-\/component of the free-\/stream velocity. Default is 1.\-0.  
\item {\ttfamily obj.\-Set\-Scalar\-Function\-Number (int num)} -\/ Specify the scalar function to extract. If ==(-\/1), then no scalar function is extracted.  
\item {\ttfamily int = obj.\-Get\-Scalar\-Function\-Number ()} -\/ Specify the scalar function to extract. If ==(-\/1), then no scalar function is extracted.  
\item {\ttfamily obj.\-Set\-Vector\-Function\-Number (int num)} -\/ Specify the vector function to extract. If ==(-\/1), then no vector function is extracted.  
\item {\ttfamily int = obj.\-Get\-Vector\-Function\-Number ()} -\/ Specify the vector function to extract. If ==(-\/1), then no vector function is extracted.  
\item {\ttfamily obj.\-Add\-Function (int function\-Number)} -\/ Specify additional functions to read. These are placed into the point data as data arrays. Later on they can be used by labeling them as scalars, etc.  
\item {\ttfamily obj.\-Remove\-Function (int )} -\/ Specify additional functions to read. These are placed into the point data as data arrays. Later on they can be used by labeling them as scalars, etc.  
\item {\ttfamily obj.\-Remove\-All\-Functions ()} -\/ Specify additional functions to read. These are placed into the point data as data arrays. Later on they can be used by labeling them as scalars, etc.  
\item {\ttfamily int = obj.\-Can\-Read\-Binary\-File (string fname)} -\/ Return 1 if the reader can read the given file name. Only meaningful for binary files.  
\end{DoxyItemize}\hypertarget{vtkio_vtkplyreader}{}\section{vtk\-P\-L\-Y\-Reader}\label{vtkio_vtkplyreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-P\-L\-Y\-Reader is a source object that reads polygonal data in Stanford University P\-L\-Y file format (see \href{http://graphics.stanford.edu/data/3Dscanrep}{\tt http\-://graphics.\-stanford.\-edu/data/3\-Dscanrep}). It requires that the elements \char`\"{}vertex\char`\"{} and \char`\"{}face\char`\"{} are defined. The \char`\"{}vertex\char`\"{} element must have the properties \char`\"{}x\char`\"{}, \char`\"{}y\char`\"{}, and \char`\"{}z\char`\"{}. The \char`\"{}face\char`\"{} element must have the property \char`\"{}vertex\-\_\-indices\char`\"{} defined. Optionally, if the \char`\"{}face\char`\"{} element has the properties \char`\"{}intensity\char`\"{} and/or the triplet \char`\"{}red\char`\"{}, \char`\"{}green\char`\"{}, and \char`\"{}blue\char`\"{}; these are read and added as scalars to the output data.

To create an instance of class vtk\-P\-L\-Y\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPLYReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-P\-L\-Y\-Reader 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\-P\-L\-Y\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-P\-L\-Y\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-P\-L\-Y\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify file name of stereo lithography file.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify file name of stereo lithography file.  
\end{DoxyItemize}\hypertarget{vtkio_vtkplywriter}{}\section{vtk\-P\-L\-Y\-Writer}\label{vtkio_vtkplywriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-P\-L\-Y\-Writer writes polygonal data in Stanford University P\-L\-Y format (see \href{http://graphics.stanford.edu/data/3Dscanrep/}{\tt http\-://graphics.\-stanford.\-edu/data/3\-Dscanrep/}). The data can be written in either binary (little or big endian) or A\-S\-C\-I\-I representation. As for Point\-Data and Cell\-Data, vtk\-P\-L\-Y\-Writer cannot handle normals or vectors. It only handles R\-G\-B Point\-Data and Cell\-Data. You need to set the name of the array (using Set\-Name for the array and Set\-Array\-Name for the writer). If the array is not a vtk\-Unsigned\-Char\-Array with 3 components, you need to specify a vtk\-Lookup\-Table to map the scalars to R\-G\-B.

To create an instance of class vtk\-P\-L\-Y\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPLYWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-P\-L\-Y\-Writer 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\-P\-L\-Y\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-P\-L\-Y\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-P\-L\-Y\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Data\-Byte\-Order (int )} -\/ If the file type is binary, then the user can specify which byte order to use (little versus big endian).  
\item {\ttfamily int = obj.\-Get\-Data\-Byte\-Order\-Min\-Value ()} -\/ If the file type is binary, then the user can specify which byte order to use (little versus big endian).  
\item {\ttfamily int = obj.\-Get\-Data\-Byte\-Order\-Max\-Value ()} -\/ If the file type is binary, then the user can specify which byte order to use (little versus big endian).  
\item {\ttfamily int = obj.\-Get\-Data\-Byte\-Order ()} -\/ If the file type is binary, then the user can specify which byte order to use (little versus big endian).  
\item {\ttfamily obj.\-Set\-Data\-Byte\-Order\-To\-Big\-Endian ()} -\/ If the file type is binary, then the user can specify which byte order to use (little versus big endian).  
\item {\ttfamily obj.\-Set\-Data\-Byte\-Order\-To\-Little\-Endian ()} -\/ These methods enable the user to control how to add color into the P\-L\-Y output file. The default behavior is as follows. The user provides the name of an array and a component number. If the type of the array is three components, unsigned char, then the data is written as three separate \char`\"{}red\char`\"{}, \char`\"{}green\char`\"{} and \char`\"{}blue\char`\"{} properties. If the type is not unsigned char, and a lookup table is provided, then the array/component are mapped through the table to generate three separate \char`\"{}red\char`\"{}, \char`\"{}green\char`\"{} and \char`\"{}blue\char`\"{} properties in the P\-L\-Y file. The user can also set the Color\-Mode to specify a uniform color for the whole part (on a vertex colors, face colors, or both. (Note\-: vertex colors or cell colors may be written, depending on where the named array is found. If points and cells have the arrays with the same name, then both colors will be written.)  
\item {\ttfamily obj.\-Set\-Color\-Mode (int )} -\/ These methods enable the user to control how to add color into the P\-L\-Y output file. The default behavior is as follows. The user provides the name of an array and a component number. If the type of the array is three components, unsigned char, then the data is written as three separate \char`\"{}red\char`\"{}, \char`\"{}green\char`\"{} and \char`\"{}blue\char`\"{} properties. If the type is not unsigned char, and a lookup table is provided, then the array/component are mapped through the table to generate three separate \char`\"{}red\char`\"{}, \char`\"{}green\char`\"{} and \char`\"{}blue\char`\"{} properties in the P\-L\-Y file. The user can also set the Color\-Mode to specify a uniform color for the whole part (on a vertex colors, face colors, or both. (Note\-: vertex colors or cell colors may be written, depending on where the named array is found. If points and cells have the arrays with the same name, then both colors will be written.)  
\item {\ttfamily int = obj.\-Get\-Color\-Mode ()} -\/ These methods enable the user to control how to add color into the P\-L\-Y output file. The default behavior is as follows. The user provides the name of an array and a component number. If the type of the array is three components, unsigned char, then the data is written as three separate \char`\"{}red\char`\"{}, \char`\"{}green\char`\"{} and \char`\"{}blue\char`\"{} properties. If the type is not unsigned char, and a lookup table is provided, then the array/component are mapped through the table to generate three separate \char`\"{}red\char`\"{}, \char`\"{}green\char`\"{} and \char`\"{}blue\char`\"{} properties in the P\-L\-Y file. The user can also set the Color\-Mode to specify a uniform color for the whole part (on a vertex colors, face colors, or both. (Note\-: vertex colors or cell colors may be written, depending on where the named array is found. If points and cells have the arrays with the same name, then both colors will be written.)  
\item {\ttfamily obj.\-Set\-Color\-Mode\-To\-Default ()} -\/ These methods enable the user to control how to add color into the P\-L\-Y output file. The default behavior is as follows. The user provides the name of an array and a component number. If the type of the array is three components, unsigned char, then the data is written as three separate \char`\"{}red\char`\"{}, \char`\"{}green\char`\"{} and \char`\"{}blue\char`\"{} properties. If the type is not unsigned char, and a lookup table is provided, then the array/component are mapped through the table to generate three separate \char`\"{}red\char`\"{}, \char`\"{}green\char`\"{} and \char`\"{}blue\char`\"{} properties in the P\-L\-Y file. The user can also set the Color\-Mode to specify a uniform color for the whole part (on a vertex colors, face colors, or both. (Note\-: vertex colors or cell colors may be written, depending on where the named array is found. If points and cells have the arrays with the same name, then both colors will be written.)  
\item {\ttfamily obj.\-Set\-Color\-Mode\-To\-Uniform\-Cell\-Color ()} -\/ These methods enable the user to control how to add color into the P\-L\-Y output file. The default behavior is as follows. The user provides the name of an array and a component number. If the type of the array is three components, unsigned char, then the data is written as three separate \char`\"{}red\char`\"{}, \char`\"{}green\char`\"{} and \char`\"{}blue\char`\"{} properties. If the type is not unsigned char, and a lookup table is provided, then the array/component are mapped through the table to generate three separate \char`\"{}red\char`\"{}, \char`\"{}green\char`\"{} and \char`\"{}blue\char`\"{} properties in the P\-L\-Y file. The user can also set the Color\-Mode to specify a uniform color for the whole part (on a vertex colors, face colors, or both. (Note\-: vertex colors or cell colors may be written, depending on where the named array is found. If points and cells have the arrays with the same name, then both colors will be written.)  
\item {\ttfamily obj.\-Set\-Color\-Mode\-To\-Uniform\-Point\-Color ()} -\/ These methods enable the user to control how to add color into the P\-L\-Y output file. The default behavior is as follows. The user provides the name of an array and a component number. If the type of the array is three components, unsigned char, then the data is written as three separate \char`\"{}red\char`\"{}, \char`\"{}green\char`\"{} and \char`\"{}blue\char`\"{} properties. If the type is not unsigned char, and a lookup table is provided, then the array/component are mapped through the table to generate three separate \char`\"{}red\char`\"{}, \char`\"{}green\char`\"{} and \char`\"{}blue\char`\"{} properties in the P\-L\-Y file. The user can also set the Color\-Mode to specify a uniform color for the whole part (on a vertex colors, face colors, or both. (Note\-: vertex colors or cell colors may be written, depending on where the named array is found. If points and cells have the arrays with the same name, then both colors will be written.)  
\item {\ttfamily obj.\-Set\-Color\-Mode\-To\-Uniform\-Color ()} -\/ These methods enable the user to control how to add color into the P\-L\-Y output file. The default behavior is as follows. The user provides the name of an array and a component number. If the type of the array is three components, unsigned char, then the data is written as three separate \char`\"{}red\char`\"{}, \char`\"{}green\char`\"{} and \char`\"{}blue\char`\"{} properties. If the type is not unsigned char, and a lookup table is provided, then the array/component are mapped through the table to generate three separate \char`\"{}red\char`\"{}, \char`\"{}green\char`\"{} and \char`\"{}blue\char`\"{} properties in the P\-L\-Y file. The user can also set the Color\-Mode to specify a uniform color for the whole part (on a vertex colors, face colors, or both. (Note\-: vertex colors or cell colors may be written, depending on where the named array is found. If points and cells have the arrays with the same name, then both colors will be written.)  
\item {\ttfamily obj.\-Set\-Color\-Mode\-To\-Off ()} -\/ Specify the array name to use to color the data.  
\item {\ttfamily obj.\-Set\-Array\-Name (string )} -\/ Specify the array name to use to color the data.  
\item {\ttfamily string = obj.\-Get\-Array\-Name ()} -\/ Specify the array name to use to color the data.  
\item {\ttfamily obj.\-Set\-Component (int )} -\/ Specify the array component to use to color the data.  
\item {\ttfamily int = obj.\-Get\-Component\-Min\-Value ()} -\/ Specify the array component to use to color the data.  
\item {\ttfamily int = obj.\-Get\-Component\-Max\-Value ()} -\/ Specify the array component to use to color the data.  
\item {\ttfamily int = obj.\-Get\-Component ()} -\/ Specify the array component to use to color the data.  
\item {\ttfamily obj.\-Set\-Lookup\-Table (vtk\-Scalars\-To\-Colors )} -\/ A lookup table can be specified in order to convert data arrays to R\-G\-B\-A colors.  
\item {\ttfamily vtk\-Scalars\-To\-Colors = obj.\-Get\-Lookup\-Table ()} -\/ A lookup table can be specified in order to convert data arrays to R\-G\-B\-A colors.  
\item {\ttfamily obj.\-Set\-Color (char , char , char )} -\/ Set the color to use when using a uniform color (either point or cells, or both). The color is specified as a triplet of three unsigned chars between (0,255). This only takes effect when the Color\-Mode is set to uniform point, uniform cell, or uniform color.  
\item {\ttfamily obj.\-Set\-Color (char a\mbox{[}3\mbox{]})} -\/ Set the color to use when using a uniform color (either point or cells, or both). The color is specified as a triplet of three unsigned chars between (0,255). This only takes effect when the Color\-Mode is set to uniform point, uniform cell, or uniform color.  
\item {\ttfamily char = obj. Get\-Color ()} -\/ Set the color to use when using a uniform color (either point or cells, or both). The color is specified as a triplet of three unsigned chars between (0,255). This only takes effect when the Color\-Mode is set to uniform point, uniform cell, or uniform color.  
\end{DoxyItemize}\hypertarget{vtkio_vtkpngreader}{}\section{vtk\-P\-N\-G\-Reader}\label{vtkio_vtkpngreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-P\-N\-G\-Reader is a source object that reads P\-N\-G files. It should be able to read most any P\-N\-G file

To create an instance of class vtk\-P\-N\-G\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPNGReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-P\-N\-G\-Reader 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\-P\-N\-G\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-P\-N\-G\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-P\-N\-G\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Can\-Read\-File (string fname)} -\/ Is the given file a P\-N\-G file?  
\item {\ttfamily string = obj.\-Get\-File\-Extensions ()} -\/ Return a descriptive name for the file format that might be useful in a G\-U\-I.  
\item {\ttfamily string = obj.\-Get\-Descriptive\-Name ()}  
\end{DoxyItemize}\hypertarget{vtkio_vtkpngwriter}{}\section{vtk\-P\-N\-G\-Writer}\label{vtkio_vtkpngwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-P\-N\-G\-Writer writes P\-N\-G files. It supports 1 to 4 component data of unsigned char or unsigned short

To create an instance of class vtk\-P\-N\-G\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPNGWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-P\-N\-G\-Writer 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\-P\-N\-G\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-P\-N\-G\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-P\-N\-G\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Write ()} -\/ The main interface which triggers the writer to start.  
\item {\ttfamily obj.\-Set\-Write\-To\-Memory (int )} -\/ Write the image to memory (a vtk\-Unsigned\-Char\-Array)  
\item {\ttfamily int = obj.\-Get\-Write\-To\-Memory ()} -\/ Write the image to memory (a vtk\-Unsigned\-Char\-Array)  
\item {\ttfamily obj.\-Write\-To\-Memory\-On ()} -\/ Write the image to memory (a vtk\-Unsigned\-Char\-Array)  
\item {\ttfamily obj.\-Write\-To\-Memory\-Off ()} -\/ Write the image to memory (a vtk\-Unsigned\-Char\-Array)  
\item {\ttfamily obj.\-Set\-Result (vtk\-Unsigned\-Char\-Array )} -\/ When writing to memory this is the result, it will be N\-U\-L\-L until the data is written the first time  
\item {\ttfamily vtk\-Unsigned\-Char\-Array = obj.\-Get\-Result ()} -\/ When writing to memory this is the result, it will be N\-U\-L\-L until the data is written the first time  
\end{DoxyItemize}\hypertarget{vtkio_vtkpnmreader}{}\section{vtk\-P\-N\-M\-Reader}\label{vtkio_vtkpnmreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-P\-N\-M\-Reader is a source object that reads pnm (portable anymap) files. This includes .pbm (bitmap), .pgm (grayscale), and .ppm (pixmap) files. (Currently this object only reads binary versions of these files.)

P\-N\-M\-Reader creates structured point datasets. The dimension of the dataset depends upon the number of files read. Reading a single file results in a 2\-D image, while reading more than one file results in a 3\-D volume.

To read a volume, files must be of the form \char`\"{}\-File\-Name.$<$number$>$\char`\"{} (e.\-g., foo.\-ppm.\-0, foo.\-ppm.\-1, ...). You must also specify the Data\-Extent. The fifth and sixth values of the Data\-Extent specify the beginning and ending files to read.

To create an instance of class vtk\-P\-N\-M\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPNMReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-P\-N\-M\-Reader 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\-P\-N\-M\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-P\-N\-M\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-P\-N\-M\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Can\-Read\-File (string fname)}  
\item {\ttfamily string = obj.\-Get\-File\-Extensions ()} -\/ P\-N\-M  
\item {\ttfamily string = obj.\-Get\-Descriptive\-Name ()}  
\end{DoxyItemize}\hypertarget{vtkio_vtkpnmwriter}{}\section{vtk\-P\-N\-M\-Writer}\label{vtkio_vtkpnmwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-P\-N\-M\-Writer writes P\-N\-M file. The data type of the file is unsigned char regardless of the input type.

To create an instance of class vtk\-P\-N\-M\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPNMWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-P\-N\-M\-Writer 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\-P\-N\-M\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-P\-N\-M\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-P\-N\-M\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkpolydatareader}{}\section{vtk\-Poly\-Data\-Reader}\label{vtkio_vtkpolydatareader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Poly\-Data\-Reader is a source object that reads A\-S\-C\-I\-I or binary polygonal data files in vtk format (see text for format details). The output of this reader is a single vtk\-Poly\-Data data object. The superclass of this class, vtk\-Data\-Reader, provides many methods for controlling the reading of the data file, see vtk\-Data\-Reader for more information.

To create an instance of class vtk\-Poly\-Data\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPolyDataReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Poly\-Data\-Reader 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\-Poly\-Data\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Poly\-Data\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Poly\-Data\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Output ()} -\/ Get the output of this reader.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Output (int idx)} -\/ Get the output of this reader.  
\item {\ttfamily obj.\-Set\-Output (vtk\-Poly\-Data output)} -\/ Get the output of this reader.  
\end{DoxyItemize}\hypertarget{vtkio_vtkpolydatawriter}{}\section{vtk\-Poly\-Data\-Writer}\label{vtkio_vtkpolydatawriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Poly\-Data\-Writer is a source object that writes A\-S\-C\-I\-I or binary polygonal data files in vtk format. See text for format details.

To create an instance of class vtk\-Poly\-Data\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPolyDataWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Poly\-Data\-Writer 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\-Poly\-Data\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Poly\-Data\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Poly\-Data\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Input ()} -\/ Get the input to this writer.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Input (int port)} -\/ Get the input to this writer.  
\end{DoxyItemize}\hypertarget{vtkio_vtkpostscriptwriter}{}\section{vtk\-Post\-Script\-Writer}\label{vtkio_vtkpostscriptwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Post\-Script\-Writer writes an image as a Post\-Script file using some reasonable scalings and centered on the page which is assumed to be about 8.\-5 by 11 inches. This is based loosely off of the code from pnmtops.\-c. Right now there aren't any real options.

To create an instance of class vtk\-Post\-Script\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPostScriptWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Post\-Script\-Writer 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\-Post\-Script\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Post\-Script\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Post\-Script\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkrectilineargridreader}{}\section{vtk\-Rectilinear\-Grid\-Reader}\label{vtkio_vtkrectilineargridreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Rectilinear\-Grid\-Reader is a source object that reads A\-S\-C\-I\-I or binary rectilinear grid data files in vtk format (see text for format details). The output of this reader is a single vtk\-Rectilinear\-Grid data object. The superclass of this class, vtk\-Data\-Reader, provides many methods for controlling the reading of the data file, see vtk\-Data\-Reader for more information.

To create an instance of class vtk\-Rectilinear\-Grid\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRectilinearGridReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Rectilinear\-Grid\-Reader 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\-Rectilinear\-Grid\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Rectilinear\-Grid\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Rectilinear\-Grid\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Rectilinear\-Grid = obj.\-Get\-Output ()} -\/ Get and set the output of this reader.  
\item {\ttfamily vtk\-Rectilinear\-Grid = obj.\-Get\-Output (int idx)} -\/ Get and set the output of this reader.  
\item {\ttfamily obj.\-Set\-Output (vtk\-Rectilinear\-Grid output)} -\/ Get and set the output of this reader.  
\item {\ttfamily int = obj.\-Read\-Meta\-Data (vtk\-Information out\-Info)} -\/ Read the meta information from the file. This needs to be public to it can be accessed by vtk\-Data\-Set\-Reader.  
\end{DoxyItemize}\hypertarget{vtkio_vtkrectilineargridwriter}{}\section{vtk\-Rectilinear\-Grid\-Writer}\label{vtkio_vtkrectilineargridwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Rectilinear\-Grid\-Writer is a source object that writes A\-S\-C\-I\-I or binary rectilinear grid data files in vtk format. See text for format details.

To create an instance of class vtk\-Rectilinear\-Grid\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRectilinearGridWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Rectilinear\-Grid\-Writer 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\-Rectilinear\-Grid\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Rectilinear\-Grid\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Rectilinear\-Grid\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Rectilinear\-Grid = obj.\-Get\-Input ()} -\/ Get the input to this writer.  
\item {\ttfamily vtk\-Rectilinear\-Grid = obj.\-Get\-Input (int port)} -\/ Get the input to this writer.  
\end{DoxyItemize}\hypertarget{vtkio_vtkrowquery}{}\section{vtk\-Row\-Query}\label{vtkio_vtkrowquery}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The abstract superclass of query classes that return row-\/oriented (table) results. A subclass will provide database-\/specific query parameters and implement the vtk\-Row\-Query A\-P\-I to return query results\-:

Execute() -\/ Execute the query. No results need to be retrieved at this point, unless you are performing caching.

Get\-Number\-Of\-Fields() -\/ After Execute() is performed, returns the number of fields in the query results.

Get\-Field\-Name() -\/ The name of the field at an index.

Get\-Field\-Type() -\/ The data type of the field at an index.

Next\-Row() -\/ Advances the query results by one row, and returns whether there are more rows left in the query.

Data\-Value() -\/ Extract a single data value from the current row.

.S\-E\-C\-T\-I\-O\-N Thanks Thanks to Andrew Wilson from Sandia National Laboratories for his work on the database classes.

To create an instance of class vtk\-Row\-Query, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRowQuery
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Row\-Query 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\-Row\-Query class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Row\-Query = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Row\-Query = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily bool = obj.\-Execute ()} -\/ Execute the query. This must be performed before any field name or data access functions are used.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Fields ()} -\/ The number of fields in the query result.  
\item {\ttfamily string = obj.\-Get\-Field\-Name (int i)} -\/ Return the name of the specified query field.  
\item {\ttfamily int = obj.\-Get\-Field\-Type (int i)} -\/ Return the type of the field, using the constants defined in vtk\-Type.\-h.  
\item {\ttfamily int = obj.\-Get\-Field\-Index (string name)} -\/ Return the index of the specified query field. Uses Get\-Number\-Of\-Fields() and Get\-Field\-Name() to match field name.  
\item {\ttfamily bool = obj.\-Next\-Row ()} -\/ Advance row, return false if past end.  
\item {\ttfamily bool = obj.\-Is\-Active ()} -\/ Return true if the query is active (i.\-e. execution was successful and results are ready to be fetched). Returns false on error or inactive query.  
\item {\ttfamily bool = obj.\-Has\-Error ()} -\/ Returns true if an error is set, otherwise false.  
\item {\ttfamily string = obj.\-Get\-Last\-Error\-Text ()} -\/ Get the last error text from the query  
\item {\ttfamily obj.\-Set\-Case\-Sensitive\-Field\-Names (bool )} -\/ Many databases do not preserve case in field names. This can cause Get\-Field\-Index to fail if you search for a field named some\-Field\-Name when the database actually stores it as S\-O\-M\-E\-F\-I\-E\-L\-D\-N\-A\-M\-E. This ivar controls whether Get\-Field\-Index() expects field names to be case-\/sensitive. The default is O\-F\-F, i.\-e. case is not preserved.  
\item {\ttfamily bool = obj.\-Get\-Case\-Sensitive\-Field\-Names ()} -\/ Many databases do not preserve case in field names. This can cause Get\-Field\-Index to fail if you search for a field named some\-Field\-Name when the database actually stores it as S\-O\-M\-E\-F\-I\-E\-L\-D\-N\-A\-M\-E. This ivar controls whether Get\-Field\-Index() expects field names to be case-\/sensitive. The default is O\-F\-F, i.\-e. case is not preserved.  
\item {\ttfamily obj.\-Case\-Sensitive\-Field\-Names\-On ()} -\/ Many databases do not preserve case in field names. This can cause Get\-Field\-Index to fail if you search for a field named some\-Field\-Name when the database actually stores it as S\-O\-M\-E\-F\-I\-E\-L\-D\-N\-A\-M\-E. This ivar controls whether Get\-Field\-Index() expects field names to be case-\/sensitive. The default is O\-F\-F, i.\-e. case is not preserved.  
\item {\ttfamily obj.\-Case\-Sensitive\-Field\-Names\-Off ()} -\/ Many databases do not preserve case in field names. This can cause Get\-Field\-Index to fail if you search for a field named some\-Field\-Name when the database actually stores it as S\-O\-M\-E\-F\-I\-E\-L\-D\-N\-A\-M\-E. This ivar controls whether Get\-Field\-Index() expects field names to be case-\/sensitive. The default is O\-F\-F, i.\-e. case is not preserved.  
\end{DoxyItemize}\hypertarget{vtkio_vtkrowquerytotable}{}\section{vtk\-Row\-Query\-To\-Table}\label{vtkio_vtkrowquerytotable}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Row\-Query\-To\-Table creates a vtk\-Table with the results of an arbitrary S\-Q\-L query. To use this filter, you first need an instance of a vtk\-S\-Q\-L\-Database subclass. You may use the database class to obtain a vtk\-Row\-Query instance. Set that query on this filter to extract the query as a table.

.S\-E\-C\-T\-I\-O\-N Thanks Thanks to Andrew Wilson from Sandia National Laboratories for his work on the database classes.

To create an instance of class vtk\-Row\-Query\-To\-Table, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRowQueryToTable
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Row\-Query\-To\-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\-Row\-Query\-To\-Table class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Row\-Query\-To\-Table = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Row\-Query\-To\-Table = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Query (vtk\-Row\-Query query)} -\/ The query to execute.  
\item {\ttfamily vtk\-Row\-Query = obj.\-Get\-Query ()} -\/ The query to execute.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Update the modified time based on the query.  
\end{DoxyItemize}\hypertarget{vtkio_vtkrtxmlpolydatareader}{}\section{vtk\-R\-T\-X\-M\-L\-Poly\-Data\-Reader}\label{vtkio_vtkrtxmlpolydatareader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-R\-T\-X\-M\-L\-Poly\-Data\-Reader reads the V\-T\-K X\-M\-L Poly\-Data file format in real time.

To create an instance of class vtk\-R\-T\-X\-M\-L\-Poly\-Data\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRTXMLPolyDataReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-R\-T\-X\-M\-L\-Poly\-Data\-Reader 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\-R\-T\-X\-M\-L\-Poly\-Data\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-R\-T\-X\-M\-L\-Poly\-Data\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-R\-T\-X\-M\-L\-Poly\-Data\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Location (string data\-Location)}  
\item {\ttfamily string = obj.\-Get\-Data\-Location ()}  
\item {\ttfamily obj.\-Update\-To\-Next\-File ()} -\/ Reader will read in the next available data file The filename is this-\/$>$Next\-File\-Name maintained internally  
\item {\ttfamily int = obj.\-New\-Data\-Available ()} -\/ check if there is new data file available in the given Data\-Location  
\item {\ttfamily obj.\-Reset\-Reader ()} -\/ Reset\-Reader check the data directory specified in this-\/$>$Data\-Location, and reset the Internal data structure specifically\-: this-\/$>$Internal-\/$>$Processed\-File\-List for monitoring the arriving new data files if Set\-Data\-Location(char$\ast$) is set by the user, this Reset\-Reader() should also be invoked.  
\item {\ttfamily string = obj.\-Get\-Next\-File\-Name ()} -\/ Return the name of the next available data file assume New\-Data\-Available() return V\-T\-K\-\_\-\-O\-K  
\end{DoxyItemize}\hypertarget{vtkio_vtksesamereader}{}\section{vtk\-S\-E\-S\-A\-M\-E\-Reader}\label{vtkio_vtksesamereader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-S\-E\-S\-A\-M\-E\-Reader is a source object that reads S\-E\-S\-A\-M\-E files. Currently supported tables include 301, 304, 502, 503, 504, 505, 602

S\-E\-S\-A\-M\-E\-Reader creates rectilinear grid datasets. The dimension of the dataset depends upon the number of densities and temperatures in the table. Values at certain temperatures and densities are stored as scalars.

To create an instance of class vtk\-S\-E\-S\-A\-M\-E\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSESAMEReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-S\-E\-S\-A\-M\-E\-Reader 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\-S\-E\-S\-A\-M\-E\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-S\-E\-S\-A\-M\-E\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-S\-E\-S\-A\-M\-E\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string file)} -\/ Set the filename to read  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Get the filename to read  
\item {\ttfamily int = obj.\-Is\-Valid\-File ()} -\/ Return whether this is a valid file  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Table\-Ids ()} -\/ Get the number of tables in this file  
\item {\ttfamily vtk\-Int\-Array = obj.\-Get\-Table\-Ids\-As\-Array ()} -\/ Returns the table ids in a data array.  
\item {\ttfamily obj.\-Set\-Table (int table\-Id)} -\/ Set the table to read in  
\item {\ttfamily int = obj.\-Get\-Table ()} -\/ Get the table to read in  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Table\-Array\-Names ()} -\/ Get the number of arrays for the table to read  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Table\-Arrays ()} -\/ Get the names of arrays for the table to read  
\item {\ttfamily string = obj.\-Get\-Table\-Array\-Name (int index)} -\/ Get the names of arrays for the table to read  
\item {\ttfamily obj.\-Set\-Table\-Array\-Status (string name, int flag)} -\/ Set whether to read a table array  
\item {\ttfamily int = obj.\-Get\-Table\-Array\-Status (string name)} -\/ Set whether to read a table array  
\end{DoxyItemize}\hypertarget{vtkio_vtkshadercodelibrary}{}\section{vtk\-Shader\-Code\-Library}\label{vtkio_vtkshadercodelibrary}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class provides the hardware shader code. .S\-E\-C\-T\-I\-O\-N Thanks Shader support in V\-T\-K includes key contributions by Gary Templet at Sandia National Labs.

To create an instance of class vtk\-Shader\-Code\-Library, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkShaderCodeLibrary
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Shader\-Code\-Library 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\-Shader\-Code\-Library class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Shader\-Code\-Library = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Shader\-Code\-Library = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtksimplepointsreader}{}\section{vtk\-Simple\-Points\-Reader}\label{vtkio_vtksimplepointsreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Simple\-Points\-Reader is a source object that reads a list of points from a file. Each point is specified by three floating-\/point values in A\-S\-C\-I\-I format. There is one point per line of the file. A vertex cell is created for each point in the output. This reader is meant as an example of how to write a reader in V\-T\-K.

To create an instance of class vtk\-Simple\-Points\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSimplePointsReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Simple\-Points\-Reader 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\-Simple\-Points\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Simple\-Points\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Simple\-Points\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Set/\-Get the name of the file from which to read points.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Set/\-Get the name of the file from which to read points.  
\end{DoxyItemize}\hypertarget{vtkio_vtkslacparticlereader}{}\section{vtk\-S\-L\-A\-C\-Particle\-Reader}\label{vtkio_vtkslacparticlereader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
A reader for a data format used by Omega3p, Tau3p, and several other tools used at the Standford Linear Accelerator Center (S\-L\-A\-C). The underlying format uses net\-C\-D\-F to store arrays, but also imposes some conventions to store a list of particles in 3\-D space.

This reader supports pieces, but in actuality only loads anything in piece 0. All other pieces are empty.

To create an instance of class vtk\-S\-L\-A\-C\-Particle\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSLACParticleReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-S\-L\-A\-C\-Particle\-Reader 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\-S\-L\-A\-C\-Particle\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-S\-L\-A\-C\-Particle\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-S\-L\-A\-C\-Particle\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily string = obj.\-Get\-File\-Name ()}  
\item {\ttfamily obj.\-Set\-File\-Name (string )}  
\end{DoxyItemize}\hypertarget{vtkio_vtkslacreader}{}\section{vtk\-S\-L\-A\-C\-Reader}\label{vtkio_vtkslacreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
A reader for a data format used by Omega3p, Tau3p, and several other tools used at the Standford Linear Accelerator Center (S\-L\-A\-C). The underlying format uses net\-C\-D\-F to store arrays, but also imposes several conventions to form an unstructured grid of elements.

To create an instance of class vtk\-S\-L\-A\-C\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSLACReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-S\-L\-A\-C\-Reader 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\-S\-L\-A\-C\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-S\-L\-A\-C\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-S\-L\-A\-C\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily string = obj.\-Get\-Mesh\-File\-Name ()}  
\item {\ttfamily obj.\-Set\-Mesh\-File\-Name (string )}  
\item {\ttfamily obj.\-Add\-Mode\-File\-Name (string fname)} -\/ There may be one mode file (usually for actual modes) or multiple mode files (which usually actually represent time series). These methods set and clear the list of mode files (which can be a single mode file).  
\item {\ttfamily obj.\-Remove\-All\-Mode\-File\-Names ()} -\/ There may be one mode file (usually for actual modes) or multiple mode files (which usually actually represent time series). These methods set and clear the list of mode files (which can be a single mode file).  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Mode\-File\-Names ()} -\/ There may be one mode file (usually for actual modes) or multiple mode files (which usually actually represent time series). These methods set and clear the list of mode files (which can be a single mode file).  
\item {\ttfamily string = obj.\-Get\-Mode\-File\-Name (int idx)} -\/ There may be one mode file (usually for actual modes) or multiple mode files (which usually actually represent time series). These methods set and clear the list of mode files (which can be a single mode file).  
\item {\ttfamily int = obj.\-Get\-Read\-Internal\-Volume ()} -\/ If on, reads the internal volume of the data set. Set to off by default.  
\item {\ttfamily obj.\-Set\-Read\-Internal\-Volume (int )} -\/ If on, reads the internal volume of the data set. Set to off by default.  
\item {\ttfamily obj.\-Read\-Internal\-Volume\-On ()} -\/ If on, reads the internal volume of the data set. Set to off by default.  
\item {\ttfamily obj.\-Read\-Internal\-Volume\-Off ()} -\/ If on, reads the internal volume of the data set. Set to off by default.  
\item {\ttfamily int = obj.\-Get\-Read\-External\-Surface ()} -\/ If on, reads the external surfaces of the data set. Set to on by default.  
\item {\ttfamily obj.\-Set\-Read\-External\-Surface (int )} -\/ If on, reads the external surfaces of the data set. Set to on by default.  
\item {\ttfamily obj.\-Read\-External\-Surface\-On ()} -\/ If on, reads the external surfaces of the data set. Set to on by default.  
\item {\ttfamily obj.\-Read\-External\-Surface\-Off ()} -\/ If on, reads the external surfaces of the data set. Set to on by default.  
\item {\ttfamily int = obj.\-Get\-Read\-Midpoints ()} -\/ If on, reads midpoint information for external surfaces and builds quadratic surface triangles. Set to on by default.  
\item {\ttfamily obj.\-Set\-Read\-Midpoints (int )} -\/ If on, reads midpoint information for external surfaces and builds quadratic surface triangles. Set to on by default.  
\item {\ttfamily obj.\-Read\-Midpoints\-On ()} -\/ If on, reads midpoint information for external surfaces and builds quadratic surface triangles. Set to on by default.  
\item {\ttfamily obj.\-Read\-Midpoints\-Off ()} -\/ If on, reads midpoint information for external surfaces and builds quadratic surface triangles. Set to on by default.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Variable\-Arrays ()} -\/ Variable array selection.  
\item {\ttfamily string = obj.\-Get\-Variable\-Array\-Name (int idx)} -\/ Variable array selection.  
\item {\ttfamily int = obj.\-Get\-Variable\-Array\-Status (string name)} -\/ Variable array selection.  
\item {\ttfamily obj.\-Set\-Variable\-Array\-Status (string name, int status)} -\/ Variable array selection.  
\end{DoxyItemize}\hypertarget{vtkio_vtkslcreader}{}\section{vtk\-S\-L\-C\-Reader}\label{vtkio_vtkslcreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-S\-L\-C\-Reader reads an S\-L\-C file and creates a structured point dataset. The size of the volume and the data spacing is set from the S\-L\-C file header.

To create an instance of class vtk\-S\-L\-C\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSLCReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-S\-L\-C\-Reader 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\-S\-L\-C\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-S\-L\-C\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-S\-L\-C\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Set/\-Get the name of the file to read.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Set/\-Get the name of the file to read.  
\item {\ttfamily int = obj.\-Get\-Error ()} -\/ Was there an error on the last read performed?  
\item {\ttfamily int = obj.\-Can\-Read\-File (string fname)} -\/ Is the given file an S\-L\-C file?  
\item {\ttfamily string = obj.\-Get\-File\-Extensions ()} -\/ S\-L\-C  
\item {\ttfamily string = obj.\-Get\-Descriptive\-Name ()}  
\end{DoxyItemize}\hypertarget{vtkio_vtksortfilenames}{}\section{vtk\-Sort\-File\-Names}\label{vtkio_vtksortfilenames}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Sort\-File\-Names will take a list of filenames (e.\-g. from a file load dialog) and sort them into one or more series. If the input list of filenames contains any directories, these can be removed before sorting using the Skip\-Directories flag. This class should be used where information about the series groupings can be determined by the filenames, but it might not be successful in cases where the information about the series groupings is stored in the files themselves (e.\-g D\-I\-C\-O\-M).

To create an instance of class vtk\-Sort\-File\-Names, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSortFileNames
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Sort\-File\-Names 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\-Sort\-File\-Names class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Sort\-File\-Names = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Sort\-File\-Names = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Grouping (int )} -\/ Sort the file names into groups, according to similarity in filename name and path. Files in different directories, or with different extensions, or which do not fit into the same numbered series will be placed into different groups. This is off by default.  
\item {\ttfamily int = obj.\-Get\-Grouping ()} -\/ Sort the file names into groups, according to similarity in filename name and path. Files in different directories, or with different extensions, or which do not fit into the same numbered series will be placed into different groups. This is off by default.  
\item {\ttfamily obj.\-Grouping\-On ()} -\/ Sort the file names into groups, according to similarity in filename name and path. Files in different directories, or with different extensions, or which do not fit into the same numbered series will be placed into different groups. This is off by default.  
\item {\ttfamily obj.\-Grouping\-Off ()} -\/ Sort the file names into groups, according to similarity in filename name and path. Files in different directories, or with different extensions, or which do not fit into the same numbered series will be placed into different groups. This is off by default.  
\item {\ttfamily obj.\-Set\-Numeric\-Sort (int )} -\/ Sort the files numerically, rather than lexicographically. For filenames that contain numbers, this means the order will be \mbox{[}\char`\"{}file8.\-dat\char`\"{}, \char`\"{}file9.\-dat\char`\"{}, \char`\"{}file10.\-dat\char`\"{}\mbox{]} instead of the usual alphabetic sorting order \mbox{[}\char`\"{}file10.\-dat\char`\"{} \char`\"{}file8.\-dat\char`\"{}, \char`\"{}file9.\-dat\char`\"{}\mbox{]}. Numeric\-Sort is off by default.  
\item {\ttfamily int = obj.\-Get\-Numeric\-Sort ()} -\/ Sort the files numerically, rather than lexicographically. For filenames that contain numbers, this means the order will be \mbox{[}\char`\"{}file8.\-dat\char`\"{}, \char`\"{}file9.\-dat\char`\"{}, \char`\"{}file10.\-dat\char`\"{}\mbox{]} instead of the usual alphabetic sorting order \mbox{[}\char`\"{}file10.\-dat\char`\"{} \char`\"{}file8.\-dat\char`\"{}, \char`\"{}file9.\-dat\char`\"{}\mbox{]}. Numeric\-Sort is off by default.  
\item {\ttfamily obj.\-Numeric\-Sort\-On ()} -\/ Sort the files numerically, rather than lexicographically. For filenames that contain numbers, this means the order will be \mbox{[}\char`\"{}file8.\-dat\char`\"{}, \char`\"{}file9.\-dat\char`\"{}, \char`\"{}file10.\-dat\char`\"{}\mbox{]} instead of the usual alphabetic sorting order \mbox{[}\char`\"{}file10.\-dat\char`\"{} \char`\"{}file8.\-dat\char`\"{}, \char`\"{}file9.\-dat\char`\"{}\mbox{]}. Numeric\-Sort is off by default.  
\item {\ttfamily obj.\-Numeric\-Sort\-Off ()} -\/ Sort the files numerically, rather than lexicographically. For filenames that contain numbers, this means the order will be \mbox{[}\char`\"{}file8.\-dat\char`\"{}, \char`\"{}file9.\-dat\char`\"{}, \char`\"{}file10.\-dat\char`\"{}\mbox{]} instead of the usual alphabetic sorting order \mbox{[}\char`\"{}file10.\-dat\char`\"{} \char`\"{}file8.\-dat\char`\"{}, \char`\"{}file9.\-dat\char`\"{}\mbox{]}. Numeric\-Sort is off by default.  
\item {\ttfamily obj.\-Set\-Ignore\-Case (int )} -\/ Ignore case when sorting. This flag is honored by both the sorting and the grouping. This is off by default.  
\item {\ttfamily int = obj.\-Get\-Ignore\-Case ()} -\/ Ignore case when sorting. This flag is honored by both the sorting and the grouping. This is off by default.  
\item {\ttfamily obj.\-Ignore\-Case\-On ()} -\/ Ignore case when sorting. This flag is honored by both the sorting and the grouping. This is off by default.  
\item {\ttfamily obj.\-Ignore\-Case\-Off ()} -\/ Ignore case when sorting. This flag is honored by both the sorting and the grouping. This is off by default.  
\item {\ttfamily obj.\-Set\-Skip\-Directories (int )} -\/ Skip directories. If this flag is set, any input item that is a directory rather than a file will not be included in the output. This is off by default.  
\item {\ttfamily int = obj.\-Get\-Skip\-Directories ()} -\/ Skip directories. If this flag is set, any input item that is a directory rather than a file will not be included in the output. This is off by default.  
\item {\ttfamily obj.\-Skip\-Directories\-On ()} -\/ Skip directories. If this flag is set, any input item that is a directory rather than a file will not be included in the output. This is off by default.  
\item {\ttfamily obj.\-Skip\-Directories\-Off ()} -\/ Skip directories. If this flag is set, any input item that is a directory rather than a file will not be included in the output. This is off by default.  
\item {\ttfamily obj.\-Set\-Input\-File\-Names (vtk\-String\-Array input)} -\/ Set a list of file names to group and sort.  
\item {\ttfamily vtk\-String\-Array = obj.\-Get\-Input\-File\-Names ()} -\/ Set a list of file names to group and sort.  
\item {\ttfamily vtk\-String\-Array = obj.\-Get\-File\-Names ()} -\/ Get the full list of sorted filenames.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Groups ()} -\/ Get the number of groups that the names were split into, if grouping is on. The filenames are automatically split into groups, where the filenames in each group will be identical except for their series numbers. If grouping is not on, this method will return zero.  
\item {\ttfamily vtk\-String\-Array = obj.\-Get\-Nth\-Group (int i)} -\/ Get the Nth group of file names. This method should only be used if grouping is on. If grouping is off, it will always return null.  
\item {\ttfamily obj.\-Update ()} -\/ Update the output filenames from the input filenames. This method is called automatically by Get\-File\-Names() and Get\-Number\-Of\-Groups() if the input names have changed.  
\end{DoxyItemize}\hypertarget{vtkio_vtksqldatabase}{}\section{vtk\-S\-Q\-L\-Database}\label{vtkio_vtksqldatabase}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Abstract base class for all S\-Q\-L database connection classes. Manages a connection to the database, and is responsible for creating instances of the associated vtk\-S\-Q\-L\-Query objects associated with this class in order to perform execute queries on the database. To allow connections to a new type of database, create both a subclass of this class and vtk\-S\-Q\-L\-Query, and implement the required functions\-:

Open() -\/ open the database connection, if possible. Close() -\/ close the connection. Get\-Query\-Instance() -\/ create and return an instance of the vtk\-S\-Q\-L\-Query subclass associated with the database type.

The subclass should also provide A\-P\-I to set connection parameters.

This class also provides the function Effect\-Schema to transform a database schema into a S\-Q\-L database.

.S\-E\-C\-T\-I\-O\-N Thanks Thanks to Andrew Wilson from Sandia National Laboratories for his work on the database classes and for the S\-Q\-Lite example. Thanks to David Thompson and Philippe Pebay from Sandia National Laboratories for implementing this class.

To create an instance of class vtk\-S\-Q\-L\-Database, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSQLDatabase
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-S\-Q\-L\-Database 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\-S\-Q\-L\-Database class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-S\-Q\-L\-Database = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-S\-Q\-L\-Database = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily bool = obj.\-Open (string password)} -\/ Open a new connection to the database. You need to set up any database parameters before calling this function. For database connections that do not require a password, pass an empty string. Returns true is the database was opened sucessfully, and false otherwise.  
\item {\ttfamily obj.\-Close ()} -\/ Close the connection to the database.  
\item {\ttfamily bool = obj.\-Is\-Open ()} -\/ Return whether the database has an open connection.  
\item {\ttfamily vtk\-S\-Q\-L\-Query = obj.\-Get\-Query\-Instance ()} -\/ Return an empty query on this database.  
\item {\ttfamily bool = obj.\-Has\-Error ()} -\/ Did the last operation generate an error  
\item {\ttfamily string = obj.\-Get\-Last\-Error\-Text ()} -\/ Get the last error text from the database I'm using const so that people do N\-O\-T use the standard vtk\-Get\-String\-Macro in their implementation, because 99\% of the time that will not be the correct thing to do...  
\item {\ttfamily string = obj.\-Get\-Database\-Type ()} -\/ Get the type of the database (e.\-g. mysql, psql,..).  
\item {\ttfamily vtk\-String\-Array = obj.\-Get\-Tables ()} -\/ Get the list of tables from the database.  
\item {\ttfamily vtk\-String\-Array = obj.\-Get\-Record (string table)} -\/ Get the list of fields for a particular table.  
\item {\ttfamily bool = obj.\-Is\-Supported (int )} -\/ Get the U\-R\-L of the database.  
\item {\ttfamily vtk\-Std\-String = obj.\-Get\-U\-R\-L ()} -\/ Get the U\-R\-L of the database.  
\item {\ttfamily vtk\-Std\-String = obj.\-Get\-Table\-Preamble (bool )} -\/ Return the S\-Q\-L string with the syntax to create a column inside a \char`\"{}\-C\-R\-E\-A\-T\-E T\-A\-B\-L\-E\char`\"{} S\-Q\-L statement. N\-B\-: this method implements the following minimally-\/portable syntax\-: $<$column name$>$=\char`\"{}\char`\"{}$>$ $<$column type$>$=\char`\"{}\char`\"{}$>$ $<$column attributes$>$=\char`\"{}\char`\"{}$>$ It must be overwritten for those S\-Q\-L backends which have a different syntax such as, e.\-g., My\-S\-Q\-L.  
\item {\ttfamily  vtk\-Std\-String = obj.\-Get\-Column\-Specification }
\begin{DoxyItemize}
\item Return the S\-Q\-L string with the syntax to create a column inside a \char`\"{}\-C\-R\-E\-A\-T\-E T\-A\-B\-L\-E\char`\"{} S\-Q\-L statement. N\-B\-: this method implements the following minimally-\/portable syntax\-: $<$column name$>$=\char`\"{}\char`\"{}$>$ $<$column type$>$=\char`\"{}\char`\"{}$>$ $<$column attributes$>$=\char`\"{}\char`\"{}$>$ It must be overwritten for those S\-Q\-L backends which have a different syntax such as, e.\-g., My\-S\-Q\-L.  
\end{DoxyItemize}
\item {\ttfamily vtk\-Std\-String = obj.\-Get\-Trigger\-Specification (vtk\-S\-Q\-L\-Database\-Schema schema, int tbl\-Handle, int trg\-Handle)} -\/ Return the S\-Q\-L string with the syntax to create a trigger using a \char`\"{}\-C\-R\-E\-A\-T\-E T\-R\-I\-G\-G\-E\-R\char`\"{} S\-Q\-L statement.  
\item {\ttfamily bool = obj.\-Effect\-Schema (vtk\-S\-Q\-L\-Database\-Schema , bool drop\-If\-Existsfalse)} -\/ Effect a database schema.  
\end{DoxyItemize}\hypertarget{vtkio_vtksqldatabaseschema}{}\section{vtk\-S\-Q\-L\-Database\-Schema}\label{vtkio_vtksqldatabaseschema}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
A class to create a S\-Q\-L database schema

.S\-E\-C\-T\-I\-O\-N Thanks Thanks to Philippe Pebay and David Thompson from Sandia National Laboratories for implementing this class.

To create an instance of class vtk\-S\-Q\-L\-Database\-Schema, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSQLDatabaseSchema
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-S\-Q\-L\-Database\-Schema 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\-S\-Q\-L\-Database\-Schema class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-S\-Q\-L\-Database\-Schema = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-S\-Q\-L\-Database\-Schema = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Add\-Preamble (string pre\-Name, string pre\-Action, string pre\-Backend\-V\-T\-K\-\_\-\-S\-Q\-L\-\_\-\-A\-L\-L\-B\-A\-C\-K\-E\-N\-D\-S)}  
\item {\ttfamily int = obj.\-Add\-Table (string tbl\-Name)} -\/ Add a table to the schema  
\item {\ttfamily int = obj.\-Add\-Column\-To\-Table (int tbl\-Handle, int col\-Type, string col\-Name, int col\-Size, string col\-Attribs)}  
\item {\ttfamily int = obj.\-Add\-Column\-To\-Table (string tbl\-Name, int col\-Type, string col\-Name, int col\-Size, string col\-Attribs)}  
\item {\ttfamily int = obj.\-Add\-Index\-To\-Table (int tbl\-Handle, int idx\-Type, string idx\-Name)}  
\item {\ttfamily int = obj.\-Add\-Index\-To\-Table (string tbl\-Name, int idx\-Type, string idx\-Name)}  
\item {\ttfamily int = obj.\-Add\-Column\-To\-Index (int tbl\-Handle, int idx\-Handle, int col\-Handle)}  
\item {\ttfamily int = obj.\-Add\-Column\-To\-Index (string tbl\-Name, string idx\-Name, string col\-Name)}  
\item {\ttfamily int = obj.\-Add\-Trigger\-To\-Table (int tbl\-Handle, int trg\-Type, string trg\-Name, string trg\-Action, string trg\-Backend\-V\-T\-K\-\_\-\-S\-Q\-L\-\_\-\-A\-L\-L\-B\-A\-C\-K\-E\-N\-D\-S)}  
\item {\ttfamily int = obj.\-Add\-Trigger\-To\-Table (string tbl\-Name, int trg\-Type, string trg\-Name, string trg\-Action, string trg\-Backend\-V\-T\-K\-\_\-\-S\-Q\-L\-\_\-\-A\-L\-L\-B\-A\-C\-K\-E\-N\-D\-S)} -\/ Given a preamble name, get its handle.  
\item {\ttfamily int = obj.\-Get\-Preamble\-Handle\-From\-Name (string pre\-Name)} -\/ Given a preamble name, get its handle.  
\item {\ttfamily string = obj.\-Get\-Preamble\-Name\-From\-Handle (int pre\-Handle)} -\/ Given a preamble handle, get its name.  
\item {\ttfamily string = obj.\-Get\-Preamble\-Action\-From\-Handle (int pre\-Handle)} -\/ Given a preamble handle, get its action.  
\item {\ttfamily string = obj.\-Get\-Preamble\-Backend\-From\-Handle (int pre\-Handle)} -\/ Given a preamble handle, get its backend.  
\item {\ttfamily int = obj.\-Get\-Table\-Handle\-From\-Name (string tbl\-Name)} -\/ Given a table name, get its handle.  
\item {\ttfamily string = obj.\-Get\-Table\-Name\-From\-Handle (int tbl\-Handle)} -\/ Given a table hanlde, get its name.  
\item {\ttfamily int = obj.\-Get\-Index\-Handle\-From\-Name (string tbl\-Name, string idx\-Name)} -\/ Given the names of a table and an index, get the handle of the index in this table.  
\item {\ttfamily string = obj.\-Get\-Index\-Name\-From\-Handle (int tbl\-Handle, int idx\-Handle)} -\/ Given the handles of a table and an index, get the name of the index.  
\item {\ttfamily int = obj.\-Get\-Index\-Type\-From\-Handle (int tbl\-Handle, int idx\-Handle)} -\/ Given the handles of a table and an index, get the type of the index.  
\item {\ttfamily string = obj.\-Get\-Index\-Column\-Name\-From\-Handle (int tbl\-Handle, int idx\-Handle, int cnm\-Handle)} -\/ Given the handles of a table, an index, and a column name, get the column name.  
\item {\ttfamily int = obj.\-Get\-Column\-Handle\-From\-Name (string tbl\-Name, string col\-Name)} -\/ Given the names of a table and a column, get the handle of the column in this table.  
\item {\ttfamily string = obj.\-Get\-Column\-Name\-From\-Handle (int tbl\-Handle, int col\-Handle)} -\/ Given the handles of a table and a column, get the name of the column.  
\item {\ttfamily int = obj.\-Get\-Column\-Type\-From\-Handle (int tbl\-Handle, int col\-Handle)} -\/ Given the handles of a table and a column, get the type of the column.  
\item {\ttfamily int = obj.\-Get\-Column\-Size\-From\-Handle (int tbl\-Handle, int col\-Handle)} -\/ Given the handles of a table and a column, get the size of the column.  
\item {\ttfamily string = obj.\-Get\-Column\-Attributes\-From\-Handle (int tbl\-Handle, int col\-Handle)} -\/ Given the handles of a table and a column, get the attributes of the column.  
\item {\ttfamily int = obj.\-Get\-Trigger\-Handle\-From\-Name (string tbl\-Name, string trg\-Name)} -\/ Given the names of a trigger and a table, get the handle of the trigger in this table.  
\item {\ttfamily string = obj.\-Get\-Trigger\-Name\-From\-Handle (int tbl\-Handle, int trg\-Handle)} -\/ Given the handles of a table and a trigger, get the name of the trigger.  
\item {\ttfamily int = obj.\-Get\-Trigger\-Type\-From\-Handle (int tbl\-Handle, int trg\-Handle)} -\/ Given the handles of a table and a trigger, get the type of the trigger.  
\item {\ttfamily string = obj.\-Get\-Trigger\-Action\-From\-Handle (int tbl\-Handle, int trg\-Handle)} -\/ Given the handles of a table and a trigger, get the action of the trigger.  
\item {\ttfamily string = obj.\-Get\-Trigger\-Backend\-From\-Handle (int tbl\-Handle, int trg\-Handle)} -\/ Given the handles of a table and a trigger, get the backend of the trigger.  
\item {\ttfamily obj.\-Reset ()} -\/ Reset the schema to its initial, empty state.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Preambles ()} -\/ Get the number of preambles.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Tables ()} -\/ Get the number of tables.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Columns\-In\-Table (int tbl\-Handle)} -\/ Get the number of columns in a particular table .  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Indices\-In\-Table (int tbl\-Handle)} -\/ Get the number of indices in a particular table .  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Column\-Names\-In\-Index (int tbl\-Handle, int idx\-Handle)} -\/ Get the number of column names associated to a particular index in a particular table .  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Triggers\-In\-Table (int tbl\-Handle)} -\/ Get the number of trigger in a particular table .  
\item {\ttfamily obj.\-Set\-Name (string )} -\/ Set/\-Get the name of the schema.  
\item {\ttfamily string = obj.\-Get\-Name ()} -\/ Set/\-Get the name of the schema.  
\end{DoxyItemize}\hypertarget{vtkio_vtksqlitedatabase}{}\section{vtk\-S\-Q\-Lite\-Database}\label{vtkio_vtksqlitedatabase}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
S\-Q\-Lite (\href{http://www.sqlite.org}{\tt http\-://www.\-sqlite.\-org}) is a public-\/domain S\-Q\-L database written in C++. It's small, fast, and can be easily embedded inside other applications. Its databases are stored in files.

This class provides a V\-T\-K interface to S\-Q\-Lite. You do not need to download any external libraries\-: we include a copy of S\-Q\-Lite 3.\-3.\-16 in V\-T\-K/\-Utilities/vtksqlite.

If you want to open a database that stays in memory and never gets written to disk, pass in the U\-R\-L 'sqlite\-://\-:memory\-:'; otherwise, specifiy the file path by passing the U\-R\-L 'sqlite\-://$<$file\-\_\-path$>$'.

.S\-E\-C\-T\-I\-O\-N Thanks Thanks to Andrew Wilson and Philippe Pebay from Sandia National Laboratories for implementing this class.

To create an instance of class vtk\-S\-Q\-Lite\-Database, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSQLiteDatabase
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-S\-Q\-Lite\-Database 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\-S\-Q\-Lite\-Database class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-S\-Q\-Lite\-Database = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-S\-Q\-Lite\-Database = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily bool = obj.\-Open (string password)} -\/ Open a new connection to the database. You need to set the filename before calling this function. Returns true if the database was opened successfully; false otherwise.
\begin{DoxyItemize}
\item U\-S\-E\-\_\-\-E\-X\-I\-S\-T\-I\-N\-G (default) -\/ Fail if the file does not exist.
\item U\-S\-E\-\_\-\-E\-X\-I\-S\-T\-I\-N\-G\-\_\-\-O\-R\-\_\-\-C\-R\-E\-A\-T\-E -\/ Create a new file if necessary.
\item C\-R\-E\-A\-T\-E\-\_\-\-O\-R\-\_\-\-C\-L\-E\-A\-R -\/ Create new or clear existing file.
\item C\-R\-E\-A\-T\-E -\/ Create new, fail if file exists.  
\end{DoxyItemize}
\item {\ttfamily bool = obj.\-Open (string password, int mode)} -\/ Open a new connection to the database. You need to set the filename before calling this function. Returns true if the database was opened successfully; false otherwise.
\begin{DoxyItemize}
\item U\-S\-E\-\_\-\-E\-X\-I\-S\-T\-I\-N\-G (default) -\/ Fail if the file does not exist.
\item U\-S\-E\-\_\-\-E\-X\-I\-S\-T\-I\-N\-G\-\_\-\-O\-R\-\_\-\-C\-R\-E\-A\-T\-E -\/ Create a new file if necessary.
\item C\-R\-E\-A\-T\-E\-\_\-\-O\-R\-\_\-\-C\-L\-E\-A\-R -\/ Create new or clear existing file.
\item C\-R\-E\-A\-T\-E -\/ Create new, fail if file exists.  
\end{DoxyItemize}
\item {\ttfamily obj.\-Close ()} -\/ Close the connection to the database.  
\item {\ttfamily bool = obj.\-Is\-Open ()} -\/ Return whether the database has an open connection  
\item {\ttfamily vtk\-S\-Q\-L\-Query = obj.\-Get\-Query\-Instance ()} -\/ Return an empty query on this database.  
\item {\ttfamily vtk\-String\-Array = obj.\-Get\-Tables ()} -\/ Get the list of tables from the database  
\item {\ttfamily vtk\-String\-Array = obj.\-Get\-Record (string table)} -\/ Get the list of fields for a particular table  
\item {\ttfamily bool = obj.\-Is\-Supported (int feature)} -\/ Return whether a feature is supported by the database.  
\item {\ttfamily bool = obj.\-Has\-Error ()} -\/ Did the last operation generate an error  
\item {\ttfamily string = obj.\-Get\-Last\-Error\-Text ()} -\/ Get the last error text from the database  
\item {\ttfamily string = obj.\-Get\-Database\-Type ()} -\/ String representing database type (e.\-g. \char`\"{}sqlite\char`\"{}).  
\item {\ttfamily string = obj.\-Get\-Database\-File\-Name ()} -\/ String representing the database filename.  
\item {\ttfamily obj.\-Set\-Database\-File\-Name (string )} -\/ String representing the database filename.  
\item {\ttfamily vtk\-Std\-String = obj.\-Get\-U\-R\-L ()} -\/ Get the U\-R\-L of the database.  
\item {\ttfamily vtk\-Std\-String = obj.\-Get\-Column\-Specification (vtk\-S\-Q\-L\-Database\-Schema schema, int tbl\-Handle, int col\-Handle)} -\/ Return the S\-Q\-L string with the syntax to create a column inside a \char`\"{}\-C\-R\-E\-A\-T\-E T\-A\-B\-L\-E\char`\"{} S\-Q\-L statement. N\-B\-: this method implements the S\-Q\-Lite-\/specific syntax\-: $<$column name$>$=\char`\"{}\char`\"{}$>$ $<$column type$>$=\char`\"{}\char`\"{}$>$ $<$column attributes$>$=\char`\"{}\char`\"{}$>$  
\end{DoxyItemize}\hypertarget{vtkio_vtksqlitequery}{}\section{vtk\-S\-Q\-Lite\-Query}\label{vtkio_vtksqlitequery}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is an implementation of vtk\-S\-Q\-L\-Query for S\-Q\-Lite databases. See the documentation for vtk\-S\-Q\-L\-Query for information about what the methods do.

.S\-E\-C\-T\-I\-O\-N Bugs

Sometimes Execute() will return false (meaning an error) but Get\-Last\-Error\-Text() winds up null. I am not certain why this is happening.

.S\-E\-C\-T\-I\-O\-N Thanks Thanks to Andrew Wilson from Sandia National Laboratories for implementing this class.

To create an instance of class vtk\-S\-Q\-Lite\-Query, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSQLiteQuery
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-S\-Q\-Lite\-Query 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\-S\-Q\-Lite\-Query class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-S\-Q\-Lite\-Query = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-S\-Q\-Lite\-Query = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily bool = obj.\-Set\-Query (string query)} -\/ Set the S\-Q\-L query string. This must be performed before Execute() or Bind\-Parameter() can be called.  
\item {\ttfamily bool = obj.\-Execute ()} -\/ Execute the query. This must be performed before any field name or data access functions are used.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Fields ()} -\/ The number of fields in the query result.  
\item {\ttfamily string = obj.\-Get\-Field\-Name (int i)} -\/ Return the name of the specified query field.  
\item {\ttfamily int = obj.\-Get\-Field\-Type (int i)} -\/ Return the type of the field, using the constants defined in vtk\-Type.\-h.  
\item {\ttfamily bool = obj.\-Next\-Row ()} -\/ Advance row, return false if past end.  
\item {\ttfamily bool = obj.\-Has\-Error ()} -\/ Return true if there is an error on the current query.  
\item {\ttfamily bool = obj.\-Begin\-Transaction ()} -\/ Begin, abort (roll back), or commit a transaction.  
\item {\ttfamily bool = obj.\-Rollback\-Transaction ()} -\/ Begin, abort (roll back), or commit a transaction.  
\item {\ttfamily bool = obj.\-Commit\-Transaction ()} -\/ Begin, abort (roll back), or commit a transaction.  
\item {\ttfamily string = obj.\-Get\-Last\-Error\-Text ()} -\/ Get the last error text from the query  
\item {\ttfamily bool = obj.\-Bind\-Parameter (int index, int value)} -\/ The following methods bind a parameter value to a placeholder in the S\-Q\-L string. See the documentation for vtk\-S\-Q\-L\-Query for further explanation. The driver makes internal copies of string and B\-L\-O\-B parameters so you don't need to worry about keeping them in scope until the query finishes executing.  
\item {\ttfamily bool = obj.\-Bind\-Parameter (int index, float value)} -\/ The following methods bind a parameter value to a placeholder in the S\-Q\-L string. See the documentation for vtk\-S\-Q\-L\-Query for further explanation. The driver makes internal copies of string and B\-L\-O\-B parameters so you don't need to worry about keeping them in scope until the query finishes executing.  
\item {\ttfamily bool = obj.\-Bind\-Parameter (int index, double value)} -\/ The following methods bind a parameter value to a placeholder in the S\-Q\-L string. See the documentation for vtk\-S\-Q\-L\-Query for further explanation. The driver makes internal copies of string and B\-L\-O\-B parameters so you don't need to worry about keeping them in scope until the query finishes executing.  
\item {\ttfamily bool = obj.\-Bind\-Parameter (int index, string string\-Value)} -\/ Bind a string value -- string must be null-\/terminated  
\item {\ttfamily bool = obj.\-Clear\-Parameter\-Bindings ()} -\/ Bind a blob value. Not all databases support blobs as a data type. Check vtk\-S\-Q\-L\-Database\-::\-Is\-Supported(\-V\-T\-K\-\_\-\-S\-Q\-L\-\_\-\-F\-E\-A\-T\-U\-R\-E\-\_\-\-B\-L\-O\-B) to make sure.  
\end{DoxyItemize}\hypertarget{vtkio_vtksqlquery}{}\section{vtk\-S\-Q\-L\-Query}\label{vtkio_vtksqlquery}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The abstract superclass of S\-Q\-L query classes. Instances of subclasses of vtk\-S\-Q\-L\-Query are created using the Get\-Query\-Instance() function in vtk\-S\-Q\-L\-Database. To implement a query connection for a new database type, subclass both vtk\-S\-Q\-L\-Database and vtk\-S\-Q\-L\-Query, and implement the required functions. For the query class, this involves the following\-:

Execute() -\/ Execute the query on the database. No results need to be retrieved at this point, unless you are performing caching.

Get\-Number\-Of\-Fields() -\/ After Execute() is performed, returns the number of fields in the query results.

Get\-Field\-Name() -\/ The name of the field at an index.

Get\-Field\-Type() -\/ The data type of the field at an index.

Next\-Row() -\/ Advances the query results by one row, and returns whether there are more rows left in the query.

Data\-Value() -\/ Extract a single data value from the current row.

Begin/\-Rollback/\-Commit\-Transaction() -\/ These methods are optional but recommended if the database supports transactions.

.S\-E\-C\-T\-I\-O\-N Thanks Thanks to Andrew Wilson from Sandia National Laboratories for his work on the database classes.

To create an instance of class vtk\-S\-Q\-L\-Query, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSQLQuery
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-S\-Q\-L\-Query 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\-S\-Q\-L\-Query class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-S\-Q\-L\-Query = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-S\-Q\-L\-Query = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily bool = obj.\-Set\-Query (string query)} -\/ The query string to be executed. Since some databases will process the query string as soon as it's set, this method returns a boolean to indicate success or failure.  
\item {\ttfamily string = obj.\-Get\-Query ()} -\/ The query string to be executed. Since some databases will process the query string as soon as it's set, this method returns a boolean to indicate success or failure.  
\item {\ttfamily bool = obj.\-Is\-Active ()} -\/ Execute the query. This must be performed before any field name or data access functions are used.  
\item {\ttfamily bool = obj.\-Execute ()} -\/ Execute the query. This must be performed before any field name or data access functions are used.  
\item {\ttfamily bool = obj.\-Begin\-Transaction ()} -\/ Begin, commit, or roll back a transaction. If the underlying database does not support transactions these calls will do nothing.  
\item {\ttfamily bool = obj.\-Commit\-Transaction ()} -\/ Begin, commit, or roll back a transaction. If the underlying database does not support transactions these calls will do nothing.  
\item {\ttfamily bool = obj.\-Rollback\-Transaction ()} -\/ Return the database associated with the query.  
\item {\ttfamily vtk\-S\-Q\-L\-Database = obj.\-Get\-Database ()} -\/ Return the database associated with the query.  
\item {\ttfamily bool = obj.\-Bind\-Parameter (int index, int value)}  
\item {\ttfamily bool = obj.\-Bind\-Parameter (int index, float value)}  
\item {\ttfamily bool = obj.\-Bind\-Parameter (int index, double value)}  
\item {\ttfamily bool = obj.\-Bind\-Parameter (int index, string string\-Value)} -\/ Bind a string value -- string must be null-\/terminated  
\item {\ttfamily bool = obj.\-Clear\-Parameter\-Bindings ()} -\/ Reset all parameter bindings to N\-U\-L\-L.  
\item {\ttfamily string = obj.\-Escape\-String (string src, bool add\-Surrounding\-Quotes)} -\/ Escape a string for inclusion into an S\-Q\-L query. This method exists to provide a wrappable version of the method that takes and returns vtk\-Std\-String objects. You are responsible for calling delete \mbox{[}\mbox{]} on the character array returned by this method. This method simply calls the vtk\-Std\-String variant and thus need not be re-\/implemented by subclasses.  
\end{DoxyItemize}\hypertarget{vtkio_vtkstlreader}{}\section{vtk\-S\-T\-L\-Reader}\label{vtkio_vtkstlreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-S\-T\-L\-Reader is a source object that reads A\-S\-C\-I\-I or binary stereo lithography files (.stl files). The File\-Name must be specified to vtk\-S\-T\-L\-Reader. The object automatically detects whether the file is A\-S\-C\-I\-I or binary.

.stl files are quite inefficient since they duplicate vertex definitions. By setting the Merging boolean you can control whether the point data is merged after reading. Merging is performed by default, however, merging requires a large amount of temporary storage since a 3\-D hash table must be constructed.

To create an instance of class vtk\-S\-T\-L\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSTLReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-S\-T\-L\-Reader 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\-S\-T\-L\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-S\-T\-L\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-S\-T\-L\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Overload standard modified time function. If locator is modified, then this object is modified as well.  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify file name of stereo lithography file.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify file name of stereo lithography file.  
\item {\ttfamily obj.\-Set\-Merging (int )} -\/ Turn on/off merging of points/triangles.  
\item {\ttfamily int = obj.\-Get\-Merging ()} -\/ Turn on/off merging of points/triangles.  
\item {\ttfamily obj.\-Merging\-On ()} -\/ Turn on/off merging of points/triangles.  
\item {\ttfamily obj.\-Merging\-Off ()} -\/ Turn on/off merging of points/triangles.  
\item {\ttfamily obj.\-Set\-Scalar\-Tags (int )} -\/ Turn on/off tagging of solids with scalars.  
\item {\ttfamily int = obj.\-Get\-Scalar\-Tags ()} -\/ Turn on/off tagging of solids with scalars.  
\item {\ttfamily obj.\-Scalar\-Tags\-On ()} -\/ Turn on/off tagging of solids with scalars.  
\item {\ttfamily obj.\-Scalar\-Tags\-Off ()} -\/ Turn on/off tagging of solids with scalars.  
\item {\ttfamily obj.\-Set\-Locator (vtk\-Incremental\-Point\-Locator locator)} -\/ Specify a spatial locator for merging points. By default an instance of vtk\-Merge\-Points is used.  
\item {\ttfamily vtk\-Incremental\-Point\-Locator = obj.\-Get\-Locator ()} -\/ Specify a spatial locator for merging points. By default an instance of vtk\-Merge\-Points is used.  
\item {\ttfamily obj.\-Create\-Default\-Locator ()} -\/ Create default locator. Used to create one when none is specified.  
\end{DoxyItemize}\hypertarget{vtkio_vtkstlwriter}{}\section{vtk\-S\-T\-L\-Writer}\label{vtkio_vtkstlwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-S\-T\-L\-Writer writes stereo lithography (.stl) files in either A\-S\-C\-I\-I or binary form. Stereo lithography files only contain triangles. If polygons with more than 3 vertices are present, only the first 3 vertices are written. Use vtk\-Triangle\-Filter to convert polygons to triangles.

To create an instance of class vtk\-S\-T\-L\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSTLWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-S\-T\-L\-Writer 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\-S\-T\-L\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-S\-T\-L\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-S\-T\-L\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkstructuredgridreader}{}\section{vtk\-Structured\-Grid\-Reader}\label{vtkio_vtkstructuredgridreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Structured\-Grid\-Reader is a source object that reads A\-S\-C\-I\-I or binary structured grid data files in vtk format. (see text for format details). The output of this reader is a single vtk\-Structured\-Grid data object. The superclass of this class, vtk\-Data\-Reader, provides many methods for controlling the reading of the data file, see vtk\-Data\-Reader for more information.

To create an instance of class vtk\-Structured\-Grid\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkStructuredGridReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Structured\-Grid\-Reader 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\-Grid\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Structured\-Grid\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Structured\-Grid\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Structured\-Grid = obj.\-Get\-Output ()} -\/ Get the output of this reader.  
\item {\ttfamily vtk\-Structured\-Grid = obj.\-Get\-Output (int idx)} -\/ Get the output of this reader.  
\item {\ttfamily obj.\-Set\-Output (vtk\-Structured\-Grid output)} -\/ Get the output of this reader.  
\item {\ttfamily int = obj.\-Read\-Meta\-Data (vtk\-Information out\-Info)} -\/ Read the meta information from the file. This needs to be public to it can be accessed by vtk\-Data\-Set\-Reader.  
\end{DoxyItemize}\hypertarget{vtkio_vtkstructuredgridwriter}{}\section{vtk\-Structured\-Grid\-Writer}\label{vtkio_vtkstructuredgridwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Structured\-Grid\-Writer is a source object that writes A\-S\-C\-I\-I or binary structured grid data files in vtk format. See text for format details.

To create an instance of class vtk\-Structured\-Grid\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkStructuredGridWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Structured\-Grid\-Writer 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\-Grid\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Structured\-Grid\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Structured\-Grid\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Structured\-Grid = obj.\-Get\-Input ()} -\/ Get the input to this writer.  
\item {\ttfamily vtk\-Structured\-Grid = obj.\-Get\-Input (int port)} -\/ Get the input to this writer.  
\end{DoxyItemize}\hypertarget{vtkio_vtkstructuredpointsreader}{}\section{vtk\-Structured\-Points\-Reader}\label{vtkio_vtkstructuredpointsreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Structured\-Points\-Reader is a source object that reads A\-S\-C\-I\-I or binary structured points data files in vtk format (see text for format details). The output of this reader is a single vtk\-Structured\-Points data object. The superclass of this class, vtk\-Data\-Reader, provides many methods for controlling the reading of the data file, see vtk\-Data\-Reader for more information.

To create an instance of class vtk\-Structured\-Points\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkStructuredPointsReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Structured\-Points\-Reader 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\-Points\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Structured\-Points\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Structured\-Points\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Output (vtk\-Structured\-Points output)} -\/ Set/\-Get the output of this reader.  
\item {\ttfamily vtk\-Structured\-Points = obj.\-Get\-Output (int idx)} -\/ Set/\-Get the output of this reader.  
\item {\ttfamily vtk\-Structured\-Points = obj.\-Get\-Output ()} -\/ Set/\-Get the output of this reader.  
\item {\ttfamily int = obj.\-Read\-Meta\-Data (vtk\-Information out\-Info)} -\/ Read the meta information from the file. This needs to be public to it can be accessed by vtk\-Data\-Set\-Reader.  
\end{DoxyItemize}\hypertarget{vtkio_vtkstructuredpointswriter}{}\section{vtk\-Structured\-Points\-Writer}\label{vtkio_vtkstructuredpointswriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Structured\-Points\-Writer is a source object that writes A\-S\-C\-I\-I or binary structured points data in vtk file format. See text for format details.

To create an instance of class vtk\-Structured\-Points\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkStructuredPointsWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Structured\-Points\-Writer 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\-Points\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Structured\-Points\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Structured\-Points\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Input ()} -\/ Get the input to this writer.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Input (int port)} -\/ Get the input to this writer.  
\end{DoxyItemize}\hypertarget{vtkio_vtktablereader}{}\section{vtk\-Table\-Reader}\label{vtkio_vtktablereader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Table\-Reader is a source object that reads A\-S\-C\-I\-I or binary vtk\-Table data files in vtk format. (see text for format details). The output of this reader is a single vtk\-Table data object. The superclass of this class, vtk\-Data\-Reader, provides many methods for controlling the reading of the data file, see vtk\-Data\-Reader for more information.

To create an instance of class vtk\-Table\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTableReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Table\-Reader 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\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Table\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Table\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Table = obj.\-Get\-Output ()} -\/ Get the output of this reader.  
\item {\ttfamily vtk\-Table = obj.\-Get\-Output (int idx)} -\/ Get the output of this reader.  
\item {\ttfamily obj.\-Set\-Output (vtk\-Table output)} -\/ Get the output of this reader.  
\end{DoxyItemize}\hypertarget{vtkio_vtktablewriter}{}\section{vtk\-Table\-Writer}\label{vtkio_vtktablewriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Table\-Writer is a sink object that writes A\-S\-C\-I\-I or binary vtk\-Table data files in vtk format. See text for format details.

To create an instance of class vtk\-Table\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTableWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Table\-Writer 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\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Table\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Table\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Table = obj.\-Get\-Input ()} -\/ Get the input to this writer.  
\item {\ttfamily vtk\-Table = obj.\-Get\-Input (int port)} -\/ Get the input to this writer.  
\end{DoxyItemize}\hypertarget{vtkio_vtktecplotreader}{}\section{vtk\-Tecplot\-Reader}\label{vtkio_vtktecplotreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Tecplot\-Reader parses an A\-S\-C\-I\-I Tecplot file to get a vtk\-Multi\-Block\-Data\-Set object made up of several vtk\-Data\-Set objects, of which each is of type either vtk\-Structured\-Grid or vtk\-Unstructured\-Grid. Each vtk\-Data\-Set object maintains the geometry, topology, and some associated attributes describing physical properties.

Tecplot treats 3\-D coordinates (only one or two coordinates might be explicitly specified in a file) as varaibles too, whose names (e.\-g., 'X' / 'x' / 'I', 'Y' / 'y' / 'J', 'Z' / 'z' / 'K') are provided in the variables list (the 'V\-A\-R\-I\-A\-B\-L\-E\-S' section). These names are then followed in the list by those of other traditional variables or attributes (node-\/ based and / or cell-\/based data with the mode specified via token 'V\-A\-R L\-O\-C\-A\-T\-I\-O\-N', to be extracted to create vtk\-Point\-Data and / or vtk\-Cell\-Data). Each zone described afterwards (in the 'Z\-O\-N\-E's section) provides the specific values of the aforementioned variables (including 3\-D coordinates), in the same order as indicated by the variable-\/names list, through either P\-O\-I\-N\-T-\/packing (i.\-e., tuple-\/based storage) or B\-L\-O\-C\-K-\/packing (component-\/based storage). In particular, the first / description line of each zone tells the type of all the constituent cells as the connectivity / topology information. In other words, the entire dataset is made up of multiple zones (blocks), of which each maintains a set of cells of the same type ('B\-R\-I\-C\-K', 'T\-R\-I\-A\-N\-G\-L\-E', 'Q\-U\-A\-D\-R\-I\-L\-A\-T\-E\-R\-A\-L', 'T\-E\-T\-R\-A\-H\-E\-D\-R\-O\-N', and 'P\-O\-I\-N\-T' in Tecplot terms). In addition, the description line of each zone specifies the zone name, dimensionality information (size of each dimension for a structured zone), number of nodes, and number of cells. Information about the file format is available at \href{http://download.tecplot.com/360/dataformat.pdf}{\tt http\-://download.\-tecplot.\-com/360/dataformat.\-pdf}.

To create an instance of class vtk\-Tecplot\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTecplotReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Tecplot\-Reader 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\-Tecplot\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Tecplot\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Tecplot\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Variables ()} -\/ Get the number of all variables (including 3\-D coordinates).  
\item {\ttfamily obj.\-Set\-File\-Name (string file\-Name)} -\/ Specify a Tecplot A\-S\-C\-I\-I file for data loading.  
\item {\ttfamily string = obj.\-Get\-Data\-Title ()} -\/ Get the Tecplot data title.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Blocks ()} -\/ Get the number of blocks (i.\-e., zones in Tecplot terms).  
\item {\ttfamily string = obj.\-Get\-Block\-Name (int block\-Idx)} -\/ Get the name of a block specified by a zero-\/based index. N\-U\-L\-L is returned for an invalid block index.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Data\-Attributes ()} -\/ Get the number of standard data attributes (node-\/based and cell-\/based), excluding 3\-D coordinates.  
\item {\ttfamily string = obj.\-Get\-Data\-Attribute\-Name (int attr\-Indx)} -\/ Get the name of a zero-\/based data attribute (not 3\-D coordinates). N\-U\-L\-L is returned for an invalid attribute index.  
\item {\ttfamily int = obj.\-Is\-Data\-Attribute\-Cell\-Based (string attr\-Name)} -\/ Get the type (0 for node-\/based and 1 for cell-\/based) of a specified data attribute (not 3\-D coordinates). -\/1 is returned for an invalid attribute name.  
\item {\ttfamily int = obj.\-Is\-Data\-Attribute\-Cell\-Based (int attr\-Indx)} -\/ Get the type (0 for node-\/based and 1 for cell-\/based) of a specified data attribute (not 3\-D coordinates). -\/1 is returned for an invalid attribute index.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Data\-Arrays ()} -\/ Get the number of all data attributes (point data and cell data).  
\item {\ttfamily string = obj.\-Get\-Data\-Array\-Name (int array\-Idx)} -\/ Get the name of a data array specified by the zero-\/based index (array\-Idx).  
\item {\ttfamily int = obj.\-Get\-Data\-Array\-Status (string aray\-Name)} -\/ Get the status of a specific data array (0\-: un-\/selected; 1\-: selected).  
\item {\ttfamily obj.\-Set\-Data\-Array\-Status (string aray\-Name, int b\-Checked)} -\/ Set the status of a specific data array (0\-: de-\/select; 1\-: select) specified by the name.  
\end{DoxyItemize}\hypertarget{vtkio_vtktiffreader}{}\section{vtk\-T\-I\-F\-F\-Reader}\label{vtkio_vtktiffreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-T\-I\-F\-F\-Reader is a source object that reads T\-I\-F\-F files. It should be able to read almost any T\-I\-F\-F file

To create an instance of class vtk\-T\-I\-F\-F\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTIFFReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-T\-I\-F\-F\-Reader 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\-T\-I\-F\-F\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-T\-I\-F\-F\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-T\-I\-F\-F\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Can\-Read\-File (string fname)} -\/ Is the given file name a tiff file file?  
\item {\ttfamily string = obj.\-Get\-File\-Extensions ()} -\/ Return a descriptive name for the file format that might be useful in a G\-U\-I.  
\item {\ttfamily string = obj.\-Get\-Descriptive\-Name ()} -\/ Auxilary methods used by the reader internally.  
\item {\ttfamily obj.\-Initialize\-Colors ()} -\/ Auxilary methods used by the reader internally.  
\item {\ttfamily obj.\-Set\-Orientation\-Type (int orientation\-Type)} -\/ Set orientation type O\-R\-I\-E\-N\-T\-A\-T\-I\-O\-N\-\_\-\-T\-O\-P\-L\-E\-F\-T 1 (row 0 top, col 0 lhs) O\-R\-I\-E\-N\-T\-A\-T\-I\-O\-N\-\_\-\-T\-O\-P\-R\-I\-G\-H\-T 2 (row 0 top, col 0 rhs) O\-R\-I\-E\-N\-T\-A\-T\-I\-O\-N\-\_\-\-B\-O\-T\-R\-I\-G\-H\-T 3 (row 0 bottom, col 0 rhs) O\-R\-I\-E\-N\-T\-A\-T\-I\-O\-N\-\_\-\-B\-O\-T\-L\-E\-F\-T 4 (row 0 bottom, col 0 lhs) O\-R\-I\-E\-N\-T\-A\-T\-I\-O\-N\-\_\-\-L\-E\-F\-T\-T\-O\-P 5 (row 0 lhs, col 0 top) O\-R\-I\-E\-N\-T\-A\-T\-I\-O\-N\-\_\-\-R\-I\-G\-H\-T\-T\-O\-P 6 (row 0 rhs, col 0 top) O\-R\-I\-E\-N\-T\-A\-T\-I\-O\-N\-\_\-\-R\-I\-G\-H\-T\-B\-O\-T 7 (row 0 rhs, col 0 bottom) O\-R\-I\-E\-N\-T\-A\-T\-I\-O\-N\-\_\-\-L\-E\-F\-T\-B\-O\-T 8 (row 0 lhs, col 0 bottom) User need to explicitely include vtk\-\_\-tiff.\-h header to have access to those \#define  
\item {\ttfamily int = obj.\-Get\-Orientation\-Type ()} -\/ Set orientation type O\-R\-I\-E\-N\-T\-A\-T\-I\-O\-N\-\_\-\-T\-O\-P\-L\-E\-F\-T 1 (row 0 top, col 0 lhs) O\-R\-I\-E\-N\-T\-A\-T\-I\-O\-N\-\_\-\-T\-O\-P\-R\-I\-G\-H\-T 2 (row 0 top, col 0 rhs) O\-R\-I\-E\-N\-T\-A\-T\-I\-O\-N\-\_\-\-B\-O\-T\-R\-I\-G\-H\-T 3 (row 0 bottom, col 0 rhs) O\-R\-I\-E\-N\-T\-A\-T\-I\-O\-N\-\_\-\-B\-O\-T\-L\-E\-F\-T 4 (row 0 bottom, col 0 lhs) O\-R\-I\-E\-N\-T\-A\-T\-I\-O\-N\-\_\-\-L\-E\-F\-T\-T\-O\-P 5 (row 0 lhs, col 0 top) O\-R\-I\-E\-N\-T\-A\-T\-I\-O\-N\-\_\-\-R\-I\-G\-H\-T\-T\-O\-P 6 (row 0 rhs, col 0 top) O\-R\-I\-E\-N\-T\-A\-T\-I\-O\-N\-\_\-\-R\-I\-G\-H\-T\-B\-O\-T 7 (row 0 rhs, col 0 bottom) O\-R\-I\-E\-N\-T\-A\-T\-I\-O\-N\-\_\-\-L\-E\-F\-T\-B\-O\-T 8 (row 0 lhs, col 0 bottom) User need to explicitely include vtk\-\_\-tiff.\-h header to have access to those \#define  
\item {\ttfamily bool = obj.\-Get\-Orientation\-Type\-Specified\-Flag ()} -\/ Get method to check if orientation type is specified  
\item {\ttfamily obj.\-Set\-Origin\-Specified\-Flag (bool )} -\/ Set/get methods to see if manual Origin/\-Spacing have been set.  
\item {\ttfamily bool = obj.\-Get\-Origin\-Specified\-Flag ()} -\/ Set/get methods to see if manual Origin/\-Spacing have been set.  
\item {\ttfamily obj.\-Origin\-Specified\-Flag\-On ()} -\/ Set/get methods to see if manual Origin/\-Spacing have been set.  
\item {\ttfamily obj.\-Origin\-Specified\-Flag\-Off ()} -\/ Set/get methods to see if manual Origin/\-Spacing have been set.  
\item {\ttfamily obj.\-Set\-Spacing\-Specified\-Flag (bool )} -\/  
\item {\ttfamily bool = obj.\-Get\-Spacing\-Specified\-Flag ()} -\/  
\item {\ttfamily obj.\-Spacing\-Specified\-Flag\-On ()} -\/  
\item {\ttfamily obj.\-Spacing\-Specified\-Flag\-Off ()} -\/  
\end{DoxyItemize}\hypertarget{vtkio_vtktiffwriter}{}\section{vtk\-T\-I\-F\-F\-Writer}\label{vtkio_vtktiffwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-T\-I\-F\-F\-Writer writes image data as a T\-I\-F\-F data file. Data can be written uncompressed or compressed. Several forms of compression are supported including packed bits, J\-P\-E\-G, deflation, and L\-Z\-W. (Note\-: L\-Z\-W compression is currently under patent in the U\-S and is disabled until the patent expires. However, the mechanism for supporting this compression is available for those with a valid license or to whom the patent does not apply.)

To create an instance of class vtk\-T\-I\-F\-F\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTIFFWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-T\-I\-F\-F\-Writer 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\-T\-I\-F\-F\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-T\-I\-F\-F\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-T\-I\-F\-F\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Compression (int )} -\/ Set compression type. Sinze L\-Z\-W compression is patented outside U\-S, the additional work steps have to be taken in order to use that compression.  
\item {\ttfamily int = obj.\-Get\-Compression\-Min\-Value ()} -\/ Set compression type. Sinze L\-Z\-W compression is patented outside U\-S, the additional work steps have to be taken in order to use that compression.  
\item {\ttfamily int = obj.\-Get\-Compression\-Max\-Value ()} -\/ Set compression type. Sinze L\-Z\-W compression is patented outside U\-S, the additional work steps have to be taken in order to use that compression.  
\item {\ttfamily int = obj.\-Get\-Compression ()} -\/ Set compression type. Sinze L\-Z\-W compression is patented outside U\-S, the additional work steps have to be taken in order to use that compression.  
\item {\ttfamily obj.\-Set\-Compression\-To\-No\-Compression ()} -\/ Set compression type. Sinze L\-Z\-W compression is patented outside U\-S, the additional work steps have to be taken in order to use that compression.  
\item {\ttfamily obj.\-Set\-Compression\-To\-Pack\-Bits ()} -\/ Set compression type. Sinze L\-Z\-W compression is patented outside U\-S, the additional work steps have to be taken in order to use that compression.  
\item {\ttfamily obj.\-Set\-Compression\-To\-J\-P\-E\-G ()} -\/ Set compression type. Sinze L\-Z\-W compression is patented outside U\-S, the additional work steps have to be taken in order to use that compression.  
\item {\ttfamily obj.\-Set\-Compression\-To\-Deflate ()} -\/ Set compression type. Sinze L\-Z\-W compression is patented outside U\-S, the additional work steps have to be taken in order to use that compression.  
\item {\ttfamily obj.\-Set\-Compression\-To\-L\-Z\-W ()}  
\end{DoxyItemize}\hypertarget{vtkio_vtktreereader}{}\section{vtk\-Tree\-Reader}\label{vtkio_vtktreereader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Tree\-Reader is a source object that reads A\-S\-C\-I\-I or binary vtk\-Tree data files in vtk format. (see text for format details). The output of this reader is a single vtk\-Tree data object. The superclass of this class, vtk\-Data\-Reader, provides many methods for controlling the reading of the data file, see vtk\-Data\-Reader for more information.

To create an instance of class vtk\-Tree\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTreeReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Tree\-Reader 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\-Tree\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Tree\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Tree\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Tree = obj.\-Get\-Output ()} -\/ Get the output of this reader.  
\item {\ttfamily vtk\-Tree = obj.\-Get\-Output (int idx)} -\/ Get the output of this reader.  
\item {\ttfamily obj.\-Set\-Output (vtk\-Tree output)} -\/ Get the output of this reader.  
\end{DoxyItemize}\hypertarget{vtkio_vtktreewriter}{}\section{vtk\-Tree\-Writer}\label{vtkio_vtktreewriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Tree\-Writer is a sink object that writes A\-S\-C\-I\-I or binary vtk\-Tree data files in vtk format. See text for format details.

To create an instance of class vtk\-Tree\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTreeWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Tree\-Writer 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\-Tree\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Tree\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Tree\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Tree = obj.\-Get\-Input ()} -\/ Get the input to this writer.  
\item {\ttfamily vtk\-Tree = obj.\-Get\-Input (int port)} -\/ Get the input to this writer.  
\end{DoxyItemize}\hypertarget{vtkio_vtkugfacetreader}{}\section{vtk\-U\-G\-Facet\-Reader}\label{vtkio_vtkugfacetreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-U\-G\-Facet\-Reader is a source object that reads Unigraphics facet files. Unigraphics is a solid modeling system; facet files are the polygonal plot files it uses to create 3\-D plots.

To create an instance of class vtk\-U\-G\-Facet\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkUGFacetReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-U\-G\-Facet\-Reader 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\-U\-G\-Facet\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-U\-G\-Facet\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-U\-G\-Facet\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Overload standard modified time function. If locator is modified, then this object is modified as well.  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify Unigraphics file name.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify Unigraphics file name.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Parts ()} -\/ Special methods for interrogating the data file.  
\item {\ttfamily short = obj.\-Get\-Part\-Color\-Index (int part\-Id)} -\/ Retrieve color index for the parts in the file.  
\item {\ttfamily obj.\-Set\-Part\-Number (int )} -\/ Specify the desired part to extract. The part number must range between \mbox{[}0,Number\-Of\-Parts-\/1\mbox{]}. If the value is =(-\/1), then all parts will be extracted. If the value is $<$(-\/1), then no parts will be extracted but the part colors will be updated.  
\item {\ttfamily int = obj.\-Get\-Part\-Number ()} -\/ Specify the desired part to extract. The part number must range between \mbox{[}0,Number\-Of\-Parts-\/1\mbox{]}. If the value is =(-\/1), then all parts will be extracted. If the value is $<$(-\/1), then no parts will be extracted but the part colors will be updated.  
\item {\ttfamily obj.\-Set\-Merging (int )} -\/ Turn on/off merging of points/triangles.  
\item {\ttfamily int = obj.\-Get\-Merging ()} -\/ Turn on/off merging of points/triangles.  
\item {\ttfamily obj.\-Merging\-On ()} -\/ Turn on/off merging of points/triangles.  
\item {\ttfamily obj.\-Merging\-Off ()} -\/ Turn on/off merging of points/triangles.  
\item {\ttfamily obj.\-Set\-Locator (vtk\-Incremental\-Point\-Locator locator)} -\/ Specify a spatial locator for merging points. By default an instance of vtk\-Merge\-Points is used.  
\item {\ttfamily vtk\-Incremental\-Point\-Locator = obj.\-Get\-Locator ()} -\/ Specify a spatial locator for merging points. By default an instance of vtk\-Merge\-Points is used.  
\item {\ttfamily obj.\-Create\-Default\-Locator ()} -\/ Create default locator. Used to create one when none is specified.  
\end{DoxyItemize}\hypertarget{vtkio_vtkunstructuredgridreader}{}\section{vtk\-Unstructured\-Grid\-Reader}\label{vtkio_vtkunstructuredgridreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Unstructured\-Grid\-Reader is a source object that reads A\-S\-C\-I\-I or binary unstructured grid data files in vtk format. (see text for format details). The output of this reader is a single vtk\-Unstructured\-Grid data object. The superclass of this class, vtk\-Data\-Reader, provides many methods for controlling the reading of the data file, see vtk\-Data\-Reader for more information.

To create an instance of class vtk\-Unstructured\-Grid\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkUnstructuredGridReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Unstructured\-Grid\-Reader 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\-Unstructured\-Grid\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Unstructured\-Grid = obj.\-Get\-Output ()} -\/ Get the output of this reader.  
\item {\ttfamily vtk\-Unstructured\-Grid = obj.\-Get\-Output (int idx)} -\/ Get the output of this reader.  
\item {\ttfamily obj.\-Set\-Output (vtk\-Unstructured\-Grid output)} -\/ Get the output of this reader.  
\end{DoxyItemize}\hypertarget{vtkio_vtkunstructuredgridwriter}{}\section{vtk\-Unstructured\-Grid\-Writer}\label{vtkio_vtkunstructuredgridwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Unstructured\-Grid\-Writer is a source object that writes A\-S\-C\-I\-I or binary unstructured grid data files in vtk format. See text for format details.

To create an instance of class vtk\-Unstructured\-Grid\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkUnstructuredGridWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Unstructured\-Grid\-Writer 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\-Unstructured\-Grid\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Unstructured\-Grid = obj.\-Get\-Input ()} -\/ Get the input to this writer.  
\item {\ttfamily vtk\-Unstructured\-Grid = obj.\-Get\-Input (int port)} -\/ Get the input to this writer.  
\end{DoxyItemize}\hypertarget{vtkio_vtkvolume16reader}{}\section{vtk\-Volume16\-Reader}\label{vtkio_vtkvolume16reader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Volume16\-Reader is a source object that reads 16 bit image files.

Volume16\-Reader creates structured point datasets. The dimension of the dataset depends upon the number of files read. Reading a single file results in a 2\-D image, while reading more than one file results in a 3\-D volume.

File names are created using File\-Pattern and File\-Prefix as follows\-: sprintf (filename, File\-Pattern, File\-Prefix, number); where number is in the range Image\-Range\mbox{[}0\mbox{]} to Image\-Range\mbox{[}1\mbox{]}. If Image\-Range\mbox{[}1\mbox{]} $<$= Image\-Range\mbox{[}0\mbox{]}, then slice number Image\-Range\mbox{[}0\mbox{]} is read. Thus to read an image set Image\-Range\mbox{[}0\mbox{]} = Image\-Range\mbox{[}1\mbox{]} = slice number. The default behavior is to read a single file (i.\-e., image slice 1).

The Data\-Mask instance variable is used to read data files with imbedded connectivity or segmentation information. For example, some data has the high order bit set to indicate connected surface. The Data\-Mask allows you to select this data. Other important ivars include Header\-Size, which allows you to skip over initial info, and Swap\-Bytes, which turns on/off byte swapping.

The Transform instance variable specifies a permutation transformation to map slice space into world space. vtk\-Image\-Reader has replaced the functionality of this class and should be used instead.

To create an instance of class vtk\-Volume16\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVolume16Reader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Volume16\-Reader 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\-Volume16\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Volume16\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Volume16\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Data\-Dimensions (int , int )} -\/ Specify the dimensions for the data.  
\item {\ttfamily obj.\-Set\-Data\-Dimensions (int a\mbox{[}2\mbox{]})} -\/ Specify the dimensions for the data.  
\item {\ttfamily int = obj. Get\-Data\-Dimensions ()} -\/ Specify the dimensions for the data.  
\item {\ttfamily obj.\-Set\-Data\-Mask (short )} -\/ Specify a mask used to eliminate data in the data file (e.\-g., connectivity bits).  
\item {\ttfamily short = obj.\-Get\-Data\-Mask ()} -\/ Specify a mask used to eliminate data in the data file (e.\-g., connectivity bits).  
\item {\ttfamily obj.\-Set\-Header\-Size (int )} -\/ Specify the number of bytes to seek over at start of image.  
\item {\ttfamily int = obj.\-Get\-Header\-Size ()} -\/ Specify the number of bytes to seek over at start of image.  
\item {\ttfamily obj.\-Set\-Data\-Byte\-Order\-To\-Big\-Endian ()} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian.  
\item {\ttfamily obj.\-Set\-Data\-Byte\-Order\-To\-Little\-Endian ()} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian.  
\item {\ttfamily int = obj.\-Get\-Data\-Byte\-Order ()} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian.  
\item {\ttfamily obj.\-Set\-Data\-Byte\-Order (int )} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian.  
\item {\ttfamily string = obj.\-Get\-Data\-Byte\-Order\-As\-String ()} -\/ These methods should be used instead of the Swap\-Bytes methods. They indicate the byte ordering of the file you are trying to read in. These methods will then either swap or not swap the bytes depending on the byte ordering of the machine it is being run on. For example, reading in a Big\-Endian file on a Big\-Endian machine will result in no swapping. Trying to read the same file on a Little\-Endian machine will result in swapping. As a quick note most U\-N\-I\-X machines are Big\-Endian while P\-C's and V\-A\-X tend to be Little\-Endian. So if the file you are reading in was generated on a V\-A\-X or P\-C, Set\-Data\-Byte\-Order\-To\-Little\-Endian otherwise Set\-Data\-Byte\-Order\-To\-Big\-Endian.  
\item {\ttfamily obj.\-Set\-Swap\-Bytes (int )} -\/ Turn on/off byte swapping.  
\item {\ttfamily int = obj.\-Get\-Swap\-Bytes ()} -\/ Turn on/off byte swapping.  
\item {\ttfamily obj.\-Swap\-Bytes\-On ()} -\/ Turn on/off byte swapping.  
\item {\ttfamily obj.\-Swap\-Bytes\-Off ()} -\/ Turn on/off byte swapping.  
\item {\ttfamily obj.\-Set\-Transform (vtk\-Transform )} -\/ Set/\-Get transformation matrix to transform the data from slice space into world space. This matrix must be a permutation matrix. To qualify, the sums of the rows must be + or -\/ 1.  
\item {\ttfamily vtk\-Transform = obj.\-Get\-Transform ()} -\/ Set/\-Get transformation matrix to transform the data from slice space into world space. This matrix must be a permutation matrix. To qualify, the sums of the rows must be + or -\/ 1.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Image (int Image\-Number)} -\/ Other objects make use of these methods  
\end{DoxyItemize}\hypertarget{vtkio_vtkvolumereader}{}\section{vtk\-Volume\-Reader}\label{vtkio_vtkvolumereader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Volume\-Reader is a source object that reads image files.

Volume\-Reader creates structured point datasets. The dimension of the dataset depends upon the number of files read. Reading a single file results in a 2\-D image, while reading more than one file results in a 3\-D volume.

File names are created using File\-Pattern and File\-Prefix as follows\-: sprintf (filename, File\-Pattern, File\-Prefix, number); where number is in the range Image\-Range\mbox{[}0\mbox{]} to Image\-Range\mbox{[}1\mbox{]}. If Image\-Range\mbox{[}1\mbox{]} $<$= Image\-Range\mbox{[}0\mbox{]}, then slice number Image\-Range\mbox{[}0\mbox{]} is read. Thus to read an image set Image\-Range\mbox{[}0\mbox{]} = Image\-Range\mbox{[}1\mbox{]} = slice number. The default behavior is to read a single file (i.\-e., image slice 1).

The Data\-Mask instance variable is used to read data files with imbedded connectivity or segmentation information. For example, some data has the high order bit set to indicate connected surface. The Data\-Mask allows you to select this data. Other important ivars include Header\-Size, which allows you to skip over initial info, and Swap\-Bytes, which turns on/off byte swapping. Consider using vtk\-Image\-Reader as a replacement.

To create an instance of class vtk\-Volume\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVolumeReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Volume\-Reader 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\-Volume\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Volume\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Volume\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Prefix (string )} -\/ Specify file prefix for the image file(s).  
\item {\ttfamily string = obj.\-Get\-File\-Prefix ()} -\/ Specify file prefix for the image file(s).  
\item {\ttfamily obj.\-Set\-File\-Pattern (string )} -\/ The sprintf format used to build filename from File\-Prefix and number.  
\item {\ttfamily string = obj.\-Get\-File\-Pattern ()} -\/ The sprintf format used to build filename from File\-Prefix and number.  
\item {\ttfamily obj.\-Set\-Image\-Range (int , int )} -\/ Set the range of files to read.  
\item {\ttfamily obj.\-Set\-Image\-Range (int a\mbox{[}2\mbox{]})} -\/ Set the range of files to read.  
\item {\ttfamily int = obj. Get\-Image\-Range ()} -\/ Set the range of files to read.  
\item {\ttfamily obj.\-Set\-Data\-Spacing (double , double , double )} -\/ Specify the spacing for the data.  
\item {\ttfamily obj.\-Set\-Data\-Spacing (double a\mbox{[}3\mbox{]})} -\/ Specify the spacing for the data.  
\item {\ttfamily double = obj. Get\-Data\-Spacing ()} -\/ Specify the spacing for the data.  
\item {\ttfamily obj.\-Set\-Data\-Origin (double , double , double )} -\/ Specify the origin for the data.  
\item {\ttfamily obj.\-Set\-Data\-Origin (double a\mbox{[}3\mbox{]})} -\/ Specify the origin for the data.  
\item {\ttfamily double = obj. Get\-Data\-Origin ()} -\/ Specify the origin for the data.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Image (int Image\-Number)} -\/ Other objects make use of this method.  
\end{DoxyItemize}\hypertarget{vtkio_vtkwriter}{}\section{vtk\-Writer}\label{vtkio_vtkwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Writer is an abstract class for mapper objects that write their data to disk (or into a communications port). All writers respond to Write() method. This method insures that there is input and input is up to date.

To create an instance of class vtk\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Writer 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\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Write ()} -\/ Write data to output. Method executes subclasses Write\-Data() method, as well as Start\-Method() and End\-Method() methods. Returns 1 on success and 0 on failure.  
\item {\ttfamily obj.\-Encode\-String (string resname, string name, bool double\-Percent)} -\/ Encode the string so that the reader will not have problems. The resulting string is up to three times the size of the input string. double\-Percent indicates whether to output a double '' before escaped characters so the string may be used as a printf format string.  
\item {\ttfamily obj.\-Set\-Input (vtk\-Data\-Object input)} -\/ Set/get the input to this writer.  
\item {\ttfamily obj.\-Set\-Input (int index, vtk\-Data\-Object input)} -\/ Set/get the input to this writer.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlcompositedatareader}{}\section{vtk\-X\-M\-L\-Composite\-Data\-Reader}\label{vtkio_vtkxmlcompositedatareader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Composite\-Data\-Reader reads the V\-T\-K X\-M\-L multi-\/group data file format. X\-M\-L multi-\/group data files are meta-\/files that point to a list of serial V\-T\-K X\-M\-L files. When reading in parallel, it will distribute sub-\/blocks among processor. If the number of sub-\/blocks is less than the number of processors, some processors will not have any sub-\/blocks for that group. If the number of sub-\/blocks is larger than the number of processors, each processor will possibly have more than 1 sub-\/block.

To create an instance of class vtk\-X\-M\-L\-Composite\-Data\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLCompositeDataReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Composite\-Data\-Reader 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\-Composite\-Data\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Composite\-Data\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Composite\-Data\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Composite\-Data\-Set = obj.\-Get\-Output ()} -\/ Get the output data object for a port on this algorithm.  
\item {\ttfamily vtk\-Composite\-Data\-Set = obj.\-Get\-Output (int )} -\/ Get the output data object for a port on this algorithm.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlcompositedatawriter}{}\section{vtk\-X\-M\-L\-Composite\-Data\-Writer}\label{vtkio_vtkxmlcompositedatawriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Composite\-Data\-Writer writes (serially) the V\-T\-K X\-M\-L multi-\/group, multi-\/block hierarchical and hierarchical box files. X\-M\-L multi-\/group data files are meta-\/files that point to a list of serial V\-T\-K X\-M\-L files.

To create an instance of class vtk\-X\-M\-L\-Composite\-Data\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLCompositeDataWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Composite\-Data\-Writer 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\-Composite\-Data\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Composite\-Data\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Composite\-Data\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily string = obj.\-Get\-Default\-File\-Extension ()} -\/ Get the default file extension for files written by this writer.  
\item {\ttfamily int = obj.\-Get\-Ghost\-Level ()} -\/ Get/\-Set the number of ghost levels to be written.  
\item {\ttfamily obj.\-Set\-Ghost\-Level (int )} -\/ Get/\-Set the number of ghost levels to be written.  
\item {\ttfamily int = obj.\-Get\-Write\-Meta\-File ()} -\/ Get/\-Set whether this instance will write the meta-\/file.  
\item {\ttfamily obj.\-Set\-Write\-Meta\-File (int flag)} -\/ Get/\-Set whether this instance will write the meta-\/file.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmldataparser}{}\section{vtk\-X\-M\-L\-Data\-Parser}\label{vtkio_vtkxmldataparser}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Data\-Parser provides a subclass of vtk\-X\-M\-L\-Parser that constructs a representation of an X\-M\-L data format's file using vtk\-X\-M\-L\-Data\-Element to represent each X\-M\-L element. This representation is then used by vtk\-X\-M\-L\-Reader and its subclasses to traverse the structure of the file and extract data.

To create an instance of class vtk\-X\-M\-L\-Data\-Parser, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLDataParser
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Data\-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\-X\-M\-L\-Data\-Parser 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\-Parser = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Data\-Parser = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-X\-M\-L\-Data\-Element = obj.\-Get\-Root\-Element ()} -\/ Get the root element from the X\-M\-L document.  
\item {\ttfamily obj.\-Set\-Compressor (vtk\-Data\-Compressor )} -\/ Get/\-Set the compressor used to decompress binary and appended data after reading from the file.  
\item {\ttfamily vtk\-Data\-Compressor = obj.\-Get\-Compressor ()} -\/ Get/\-Set the compressor used to decompress binary and appended data after reading from the file.  
\item {\ttfamily long = obj.\-Get\-Word\-Type\-Size (int word\-Type)} -\/ Get the size of a word of the given type.  
\item {\ttfamily int = obj.\-Parse ()} -\/ Parse the X\-M\-L input and check that the file is safe to read. Returns 1 for okay, 0 for error.  
\item {\ttfamily int = obj.\-Get\-Abort ()} -\/ Get/\-Set flag to abort reading of data. This may be set by a progress event observer.  
\item {\ttfamily obj.\-Set\-Abort (int )} -\/ Get/\-Set flag to abort reading of data. This may be set by a progress event observer.  
\item {\ttfamily float = obj.\-Get\-Progress ()} -\/ Get/\-Set progress of reading data. This may be checked by a progress event observer.  
\item {\ttfamily obj.\-Set\-Progress (float )} -\/ Get/\-Set progress of reading data. This may be checked by a progress event observer.  
\item {\ttfamily obj.\-Set\-Attributes\-Encoding (int )} -\/ Get/\-Set the character encoding that will be used to set the attributes's encoding type of each vtk\-X\-M\-L\-Data\-Element created by this parser (i.\-e., the data element attributes will use that encoding internally). If set to V\-T\-K\-\_\-\-E\-N\-C\-O\-D\-I\-N\-G\-\_\-\-N\-O\-N\-E (default), the attribute encoding type will not be changed and will default to the vtk\-X\-M\-L\-Data\-Element default encoding type (see vtk\-X\-M\-L\-Data\-Element\-::\-Attribute\-Encoding).  
\item {\ttfamily int = obj.\-Get\-Attributes\-Encoding\-Min\-Value ()} -\/ Get/\-Set the character encoding that will be used to set the attributes's encoding type of each vtk\-X\-M\-L\-Data\-Element created by this parser (i.\-e., the data element attributes will use that encoding internally). If set to V\-T\-K\-\_\-\-E\-N\-C\-O\-D\-I\-N\-G\-\_\-\-N\-O\-N\-E (default), the attribute encoding type will not be changed and will default to the vtk\-X\-M\-L\-Data\-Element default encoding type (see vtk\-X\-M\-L\-Data\-Element\-::\-Attribute\-Encoding).  
\item {\ttfamily int = obj.\-Get\-Attributes\-Encoding\-Max\-Value ()} -\/ Get/\-Set the character encoding that will be used to set the attributes's encoding type of each vtk\-X\-M\-L\-Data\-Element created by this parser (i.\-e., the data element attributes will use that encoding internally). If set to V\-T\-K\-\_\-\-E\-N\-C\-O\-D\-I\-N\-G\-\_\-\-N\-O\-N\-E (default), the attribute encoding type will not be changed and will default to the vtk\-X\-M\-L\-Data\-Element default encoding type (see vtk\-X\-M\-L\-Data\-Element\-::\-Attribute\-Encoding).  
\item {\ttfamily int = obj.\-Get\-Attributes\-Encoding ()} -\/ Get/\-Set the character encoding that will be used to set the attributes's encoding type of each vtk\-X\-M\-L\-Data\-Element created by this parser (i.\-e., the data element attributes will use that encoding internally). If set to V\-T\-K\-\_\-\-E\-N\-C\-O\-D\-I\-N\-G\-\_\-\-N\-O\-N\-E (default), the attribute encoding type will not be changed and will default to the vtk\-X\-M\-L\-Data\-Element default encoding type (see vtk\-X\-M\-L\-Data\-Element\-::\-Attribute\-Encoding).  
\item {\ttfamily obj.\-Character\-Data\-Handler (string data, int length)} -\/ If you need the text inside X\-M\-L\-Elements, turn Ignore\-Character\-Data off. This method will then be called when the file is parsed, and the text will be stored in each X\-M\-L\-Data\-Element. V\-T\-K X\-M\-L Readers store the information elsewhere, so the default is to ignore it.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmldatareader}{}\section{vtk\-X\-M\-L\-Data\-Reader}\label{vtkio_vtkxmldatareader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Data\-Reader provides functionality common to all V\-T\-K X\-M\-L file readers. Concrete subclasses call upon this functionality when needed.

To create an instance of class vtk\-X\-M\-L\-Data\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLDataReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Data\-Reader 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\-Reader 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\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Data\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Points ()} -\/ Get the number of points in the output.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Cells ()} -\/ Get the number of cells in the output.  
\item {\ttfamily obj.\-Copy\-Output\-Information (vtk\-Information out\-Info, int port)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmldatasetwriter}{}\section{vtk\-X\-M\-L\-Data\-Set\-Writer}\label{vtkio_vtkxmldatasetwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Data\-Set\-Writer is a wrapper around the V\-T\-K X\-M\-L file format writers. Given an input vtk\-Data\-Set, the correct writer is automatically selected based on the type of input.

To create an instance of class vtk\-X\-M\-L\-Data\-Set\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLDataSetWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Data\-Set\-Writer 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\-Set\-Writer 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\-Set\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Data\-Set\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlfilereadtester}{}\section{vtk\-X\-M\-L\-File\-Read\-Tester}\label{vtkio_vtkxmlfilereadtester}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-File\-Read\-Tester reads the smallest part of a file necessary to determine whether it is a V\-T\-K X\-M\-L file. If so, it extracts the file type and version number.

To create an instance of class vtk\-X\-M\-L\-File\-Read\-Tester, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLFileReadTester
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-File\-Read\-Tester 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\-Read\-Tester 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\-Read\-Tester = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-File\-Read\-Tester = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Test\-Read\-File ()} -\/ Try to read the file given by File\-Name. Returns 1 if the file is a V\-T\-K X\-M\-L file, and 0 otherwise.  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Get/\-Set the name of the file tested by Test\-Read\-File().  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Get/\-Set the name of the file tested by Test\-Read\-File().  
\item {\ttfamily string = obj.\-Get\-File\-Data\-Type ()} -\/ Get the data type of the X\-M\-L file tested. If the file could not be read, returns N\-U\-L\-L.  
\item {\ttfamily string = obj.\-Get\-File\-Version ()} -\/ Get the file version of the X\-M\-L file tested. If the file could not be read, returns N\-U\-L\-L.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlhierarchicalboxdatareader}{}\section{vtk\-X\-M\-L\-Hierarchical\-Box\-Data\-Reader}\label{vtkio_vtkxmlhierarchicalboxdatareader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Hierarchical\-Box\-Data\-Reader reads the V\-T\-K X\-M\-L hierarchical data file format. X\-M\-L hierarchical data files are meta-\/files that point to a list of serial V\-T\-K X\-M\-L files. When reading in parallel, it will distribute sub-\/blocks among processor. If the number of sub-\/blocks is less than the number of processors, some processors will not have any sub-\/blocks for that level. If the number of sub-\/blocks is larger than the number of processors, each processor will possibly have more than 1 sub-\/block.

To create an instance of class vtk\-X\-M\-L\-Hierarchical\-Box\-Data\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLHierarchicalBoxDataReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Hierarchical\-Box\-Data\-Reader 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\-Hierarchical\-Box\-Data\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Hierarchical\-Box\-Data\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Hierarchical\-Box\-Data\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlhierarchicalboxdatawriter}{}\section{vtk\-X\-M\-L\-Hierarchical\-Box\-Data\-Writer}\label{vtkio_vtkxmlhierarchicalboxdatawriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Hierarchical\-Box\-Data\-Writer is a vtk\-X\-M\-L\-Composite\-Data\-Writer subclass to handle vtk\-Hierarchical\-Box\-Data\-Set.

To create an instance of class vtk\-X\-M\-L\-Hierarchical\-Box\-Data\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLHierarchicalBoxDataWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Hierarchical\-Box\-Data\-Writer 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\-Hierarchical\-Box\-Data\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Hierarchical\-Box\-Data\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Hierarchical\-Box\-Data\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily string = obj.\-Get\-Default\-File\-Extension ()}  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlhierarchicaldatareader}{}\section{vtk\-X\-M\-L\-Hierarchical\-Data\-Reader}\label{vtkio_vtkxmlhierarchicaldatareader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Hierarchical\-Data\-Reader reads the V\-T\-K X\-M\-L hierarchical data file format. X\-M\-L hierarchical data files are meta-\/files that point to a list of serial V\-T\-K X\-M\-L files. When reading in parallel, it will distribute sub-\/blocks among processor. If the number of sub-\/blocks is less than the number of processors, some processors will not have any sub-\/blocks for that level. If the number of sub-\/blocks is larger than the number of processors, each processor will possibly have more than 1 sub-\/block.

To create an instance of class vtk\-X\-M\-L\-Hierarchical\-Data\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLHierarchicalDataReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Hierarchical\-Data\-Reader 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\-Hierarchical\-Data\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Hierarchical\-Data\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Hierarchical\-Data\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlhyperoctreereader}{}\section{vtk\-X\-M\-L\-Hyper\-Octree\-Reader}\label{vtkio_vtkxmlhyperoctreereader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Hyper\-Octree\-Reader reads the V\-T\-K X\-M\-L Hyper\-Octree file format. One rectilinear grid file can be read to produce one output. Streaming is supported. The standard extension for this reader's file format is \char`\"{}vto\char`\"{}. This reader is also used to read a single piece of the parallel file format.

To create an instance of class vtk\-X\-M\-L\-Hyper\-Octree\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLHyperOctreeReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Hyper\-Octree\-Reader 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\-Hyper\-Octree\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Hyper\-Octree\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Hyper\-Octree\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Hyper\-Octree = obj.\-Get\-Output ()} -\/ Get the reader's output.  
\item {\ttfamily vtk\-Hyper\-Octree = obj.\-Get\-Output (int idx)} -\/ Get the reader's output.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlhyperoctreewriter}{}\section{vtk\-X\-M\-L\-Hyper\-Octree\-Writer}\label{vtkio_vtkxmlhyperoctreewriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Hyper\-Octree\-Writer writes the V\-T\-K X\-M\-L Hyper\-Octree file format. One Hyper\-Octree input can be written into one file in any number of streamed pieces. The standard extension for this writer's file format is \char`\"{}vto\char`\"{}. This writer is also used to write a single piece of the parallel file format.

To create an instance of class vtk\-X\-M\-L\-Hyper\-Octree\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLHyperOctreeWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Hyper\-Octree\-Writer 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\-Hyper\-Octree\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Hyper\-Octree\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Hyper\-Octree\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily string = obj.\-Get\-Default\-File\-Extension ()} -\/ Get the default file extension for files written by this writer.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlimagedatareader}{}\section{vtk\-X\-M\-L\-Image\-Data\-Reader}\label{vtkio_vtkxmlimagedatareader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Image\-Data\-Reader reads the V\-T\-K X\-M\-L Image\-Data file format. One image data file can be read to produce one output. Streaming is supported. The standard extension for this reader's file format is \char`\"{}vti\char`\"{}. This reader is also used to read a single piece of the parallel file format.

To create an instance of class vtk\-X\-M\-L\-Image\-Data\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLImageDataReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Image\-Data\-Reader 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\-Image\-Data\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Image\-Data\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Image\-Data\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Output ()} -\/ Get the reader's output.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Output (int idx)} -\/ Get the reader's output.  
\item {\ttfamily obj.\-Copy\-Output\-Information (vtk\-Information out\-Info, int port)} -\/ For the specified port, copy the information this reader sets up in Setup\-Output\-Information to out\-Info  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlimagedatawriter}{}\section{vtk\-X\-M\-L\-Image\-Data\-Writer}\label{vtkio_vtkxmlimagedatawriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Image\-Data\-Writer writes the V\-T\-K X\-M\-L Image\-Data file format. One image data input can be written into one file in any number of streamed pieces. The standard extension for this writer's file format is \char`\"{}vti\char`\"{}. This writer is also used to write a single piece of the parallel file format.

To create an instance of class vtk\-X\-M\-L\-Image\-Data\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLImageDataWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Image\-Data\-Writer 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\-Image\-Data\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Image\-Data\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Image\-Data\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily string = obj.\-Get\-Default\-File\-Extension ()} -\/ Get the default file extension for files written by this writer.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlmaterial}{}\section{vtk\-X\-M\-L\-Material}\label{vtkio_vtkxmlmaterial}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Material encapsulates V\-T\-K Material description. It keeps a pointer to vtk\-X\-M\-L\-Data\-Element that defines the material and provides access to Shaders/\-Properties defined in it. .S\-E\-C\-T\-I\-O\-N Thanks Shader support in V\-T\-K includes key contributions by Gary Templet at Sandia National Labs.

To create an instance of class vtk\-X\-M\-L\-Material, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLMaterial
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Material 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\-Material class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Material = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Material = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Properties ()} -\/ Get number of elements of type Property.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Textures ()} -\/ Get number of elements of type Texture.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Vertex\-Shaders ()} -\/ Get number of Vertex shaders.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Fragment\-Shaders ()} -\/ Get number of fragment shaders.  
\item {\ttfamily vtk\-X\-M\-L\-Data\-Element = obj.\-Get\-Property (int id)} -\/ Get the ith vtk\-X\-M\-L\-Data\-Element of type $<$\-Property$>$.  
\item {\ttfamily vtk\-X\-M\-L\-Data\-Element = obj.\-Get\-Texture (int id)} -\/ Get the ith vtk\-X\-M\-L\-Data\-Element of type $<$\-Texture$>$.  
\item {\ttfamily vtk\-X\-M\-L\-Shader = obj.\-Get\-Vertex\-Shader (int id)} -\/ Get the ith vtk\-X\-M\-L\-Data\-Element of type $<$\-Vertex\-Shader$>$.  
\item {\ttfamily vtk\-X\-M\-L\-Shader = obj.\-Get\-Fragment\-Shader (int id)} -\/ Get the ith vtk\-X\-M\-L\-Data\-Element of type $<$\-Fragment\-Shader$>$.  
\item {\ttfamily vtk\-X\-M\-L\-Data\-Element = obj.\-Get\-Root\-Element ()} -\/ Get/\-Set the X\-M\-L root element that describes this material.  
\item {\ttfamily obj.\-Set\-Root\-Element (vtk\-X\-M\-L\-Data\-Element )} -\/ Get/\-Set the X\-M\-L root element that describes this material.  
\item {\ttfamily int = obj.\-Get\-Shader\-Language ()} -\/ Get the Language used by the shaders in this Material. The Language of a vtk\-X\-M\-L\-Material is based on the Language of it's shaders.  
\item {\ttfamily int = obj.\-Get\-Shader\-Style ()} -\/ Get the style the shaders. \begin{DoxyPostcond}{Postcondition}
valid\-\_\-result\-: result==1 $|$$|$ result==2  
\end{DoxyPostcond}

\end{DoxyItemize}\hypertarget{vtkio_vtkxmlmaterialparser}{}\section{vtk\-X\-M\-L\-Material\-Parser}\label{vtkio_vtkxmlmaterialparser}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Material\-Parser parses a V\-T\-K Material file and provides that file's description of a number of vertex and fragment shaders along with data values specified for data members of vtk\-Property. This material is to be applied to an actor through it's vtk\-Property and augments V\-T\-K's concept of a vtk\-Property to include explicitly include vertex and fragment shaders and parameter settings for those shaders. This effectively makes reflectance models and other shaders a material property. If no shaders are specified V\-T\-K should default to standard rendering.

.S\-E\-C\-T\-I\-O\-N Design vtk\-X\-M\-L\-Material\-Parser provides access to 3 distinct types of first-\/level vtk\-X\-M\-L\-Data\-Elements that describe a V\-T\-K material. These elements are as follows\-:

vtk\-Property -\/ describe values for vtk\-Property data members

vtk\-Vertex\-Shader -\/ a vertex shader and enough information to install it into the hardware rendering pipeline including values for specific shader parameters and structures.

vtk\-Fragment\-Shader -\/ a fragment shader and enough information to install it into the hardware rendering pipeline including values for specific shader parameters and structures.

The design of the material file closely follows that of vtk's xml descriptions of it's data sets. This allows use of the very handy vtk\-X\-M\-L\-Data\-Element which provides easy access to an xml element's attribute values. Inlined data is currently not handled.

Ideally this class would be a Facade to a D\-O\-M parser, but V\-T\-K only provides access to expat, a S\-A\-X parser. Other vtk classes that parse xml files are tuned to read vtk\-Data\-Sets and don't provide the functionality to handle generic xml data. As such they are of little use here.

This class may be extended for better data handling or may become a Facade to a D\-O\-M parser should on become part of the V\-T\-K code base. .S\-E\-C\-T\-I\-O\-N Thanks Shader support in V\-T\-K includes key contributions by Gary Templet at Sandia National Labs.

To create an instance of class vtk\-X\-M\-L\-Material\-Parser, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLMaterialParser
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Material\-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\-X\-M\-L\-Material\-Parser class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Material\-Parser = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Material\-Parser = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-X\-M\-L\-Material = obj.\-Get\-Material ()} -\/ Set/\-Get the vtk\-X\-M\-L\-Material representation of the parsed material.  
\item {\ttfamily obj.\-Set\-Material (vtk\-X\-M\-L\-Material )} -\/ Set/\-Get the vtk\-X\-M\-L\-Material representation of the parsed material.  
\item {\ttfamily int = obj.\-Parse ()} -\/ Overridden to initialize the internal structures before the parsing begins.  
\item {\ttfamily int = obj.\-Parse (string input\-String)} -\/ Overridden to initialize the internal structures before the parsing begins.  
\item {\ttfamily int = obj.\-Parse (string input\-String, int length)} -\/ Overridden to initialize the internal structures before the parsing begins.  
\item {\ttfamily int = obj.\-Initialize\-Parser ()} -\/ Overridden to clean up internal structures before the chunk-\/parsing begins.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlmaterialreader}{}\section{vtk\-X\-M\-L\-Material\-Reader}\label{vtkio_vtkxmlmaterialreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Material\-Reader provides access to three types of vtk\-X\-M\-L\-Data\-Element found in X\-M\-L Material Files. This class sorts them by type and integer id from 0-\/\-N for N elements of a specific type starting with the first instance found.

.S\-E\-C\-T\-I\-O\-N Design This class is basically a Facade for vtk\-X\-M\-L\-Material\-Parser. Currently functionality is to only provide access to vtk\-X\-M\-L\-Data\-Elements but further extensions may return higher level data structures.

Having both an vtk\-X\-M\-L\-Material\-Parser and a vtk\-X\-M\-L\-Material\-Reader is consistent with V\-T\-K's design for handling xml file and provides for future flexibility, that is better data handlers and interfacing with a D\-O\-M xml parser.

vtk\-Property -\/ defines values for some or all data members of vtk\-Property

vtk\-Vertex\-Shader -\/ defines vertex shaders

vtk\-Fragment\-Shader -\/ defines fragment shaders .S\-E\-C\-T\-I\-O\-N Thanks Shader support in V\-T\-K includes key contributions by Gary Templet at Sandia National Labs.

To create an instance of class vtk\-X\-M\-L\-Material\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLMaterialReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Material\-Reader 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\-Material\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Material\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Material\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Set and get file name.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Set and get file name.  
\item {\ttfamily obj.\-Read\-Material ()} -\/ Read the material file refered to in File\-Name. If the Reader hasn't changed since the last Read\-Material(), it does not read the file again.  
\item {\ttfamily vtk\-X\-M\-L\-Material = obj.\-Get\-Material ()} -\/ Get the Material representation read by the reader.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlmultiblockdatareader}{}\section{vtk\-X\-M\-L\-Multi\-Block\-Data\-Reader}\label{vtkio_vtkxmlmultiblockdatareader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Multi\-Block\-Data\-Reader reads the V\-T\-K X\-M\-L multi-\/block data file format. X\-M\-L multi-\/block data files are meta-\/files that point to a list of serial V\-T\-K X\-M\-L files. When reading in parallel, it will distribute sub-\/blocks among processor. If the number of sub-\/blocks is less than the number of processors, some processors will not have any sub-\/blocks for that block. If the number of sub-\/blocks is larger than the number of processors, each processor will possibly have more than 1 sub-\/block.

To create an instance of class vtk\-X\-M\-L\-Multi\-Block\-Data\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLMultiBlockDataReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Multi\-Block\-Data\-Reader 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\-Multi\-Block\-Data\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Multi\-Block\-Data\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Multi\-Block\-Data\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlmultiblockdatawriter}{}\section{vtk\-X\-M\-L\-Multi\-Block\-Data\-Writer}\label{vtkio_vtkxmlmultiblockdatawriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Multi\-Block\-Data\-Writer is a vtk\-X\-M\-L\-Composite\-Data\-Writer subclass to handle vtk\-Multi\-Block\-Data\-Set.

To create an instance of class vtk\-X\-M\-L\-Multi\-Block\-Data\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLMultiBlockDataWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Multi\-Block\-Data\-Writer 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\-Multi\-Block\-Data\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Multi\-Block\-Data\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Multi\-Block\-Data\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily string = obj.\-Get\-Default\-File\-Extension ()}  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlmultigroupdatareader}{}\section{vtk\-X\-M\-L\-Multi\-Group\-Data\-Reader}\label{vtkio_vtkxmlmultigroupdatareader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Multi\-Group\-Data\-Reader is a legacy reader that reads multi group files into multiblock datasets.

To create an instance of class vtk\-X\-M\-L\-Multi\-Group\-Data\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLMultiGroupDataReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Multi\-Group\-Data\-Reader 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\-Multi\-Group\-Data\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Multi\-Group\-Data\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Multi\-Group\-Data\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlparser}{}\section{vtk\-X\-M\-L\-Parser}\label{vtkio_vtkxmlparser}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Parser reads a stream and parses X\-M\-L element tags and corresponding attributes. Each element begin tag and its attributes are sent to the Start\-Element method. Each element end tag is sent to the End\-Element method. Subclasses should replace these methods to actually use the tags. .S\-E\-C\-T\-I\-O\-N To\-Do\-: Add commands for parsing in Tcl.

To create an instance of class vtk\-X\-M\-L\-Parser, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLParser
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-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\-X\-M\-L\-Parser class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Parser = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Parser = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily long = obj.\-Tell\-G ()} -\/ Used by subclasses and their supporting classes. These methods wrap around the tellg and seekg methods of the input stream to work-\/around stream bugs on various platforms.  
\item {\ttfamily obj.\-Seek\-G (long position)} -\/ Used by subclasses and their supporting classes. These methods wrap around the tellg and seekg methods of the input stream to work-\/around stream bugs on various platforms.  
\item {\ttfamily int = obj.\-Parse ()} -\/ Parse the X\-M\-L input.  
\item {\ttfamily int = obj.\-Parse (string input\-String)} -\/ Parse the X\-M\-L message. If length is specified, parse only the first \char`\"{}length\char`\"{} characters  
\item {\ttfamily int = obj.\-Parse (string input\-String, int length)} -\/ Parse the X\-M\-L message. If length is specified, parse only the first \char`\"{}length\char`\"{} characters  
\item {\ttfamily int = obj.\-Initialize\-Parser ()} -\/ When parsing fragments of X\-M\-L or streaming X\-M\-L, use the following three methods. Initialize\-Parser method initialize parser but does not perform any actual parsing. Parse\-Chunk parses framgent of X\-M\-L. This has to match to what was already parsed. Cleanup\-Parser finishes parsing. If there were errors, Cleanup\-Parser will report them.  
\item {\ttfamily int = obj.\-Parse\-Chunk (string input\-String, int length)} -\/ When parsing fragments of X\-M\-L or streaming X\-M\-L, use the following three methods. Initialize\-Parser method initialize parser but does not perform any actual parsing. Parse\-Chunk parses framgent of X\-M\-L. This has to match to what was already parsed. Cleanup\-Parser finishes parsing. If there were errors, Cleanup\-Parser will report them.  
\item {\ttfamily int = obj.\-Cleanup\-Parser ()} -\/ When parsing fragments of X\-M\-L or streaming X\-M\-L, use the following three methods. Initialize\-Parser method initialize parser but does not perform any actual parsing. Parse\-Chunk parses framgent of X\-M\-L. This has to match to what was already parsed. Cleanup\-Parser finishes parsing. If there were errors, Cleanup\-Parser will report them.  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Set and get file name.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Set and get file name.  
\item {\ttfamily obj.\-Set\-Ignore\-Character\-Data (int )} -\/ If this is off (the default), Character\-Data\-Handler will be called to process text within X\-M\-L Elements. If this is on, the text will be ignored.  
\item {\ttfamily int = obj.\-Get\-Ignore\-Character\-Data ()} -\/ If this is off (the default), Character\-Data\-Handler will be called to process text within X\-M\-L Elements. If this is on, the text will be ignored.  
\item {\ttfamily obj.\-Set\-Encoding (string )} -\/ Set and get the encoding the parser should expect (N\-U\-L\-L defaults to Expat's own default encoder, i.\-e U\-T\-F-\/8). This should be set before parsing (i.\-e. a call to Parse()) or even initializing the parser (i.\-e. a call to Initialize\-Parser())  
\item {\ttfamily string = obj.\-Get\-Encoding ()} -\/ Set and get the encoding the parser should expect (N\-U\-L\-L defaults to Expat's own default encoder, i.\-e U\-T\-F-\/8). This should be set before parsing (i.\-e. a call to Parse()) or even initializing the parser (i.\-e. a call to Initialize\-Parser())  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlpdatareader}{}\section{vtk\-X\-M\-L\-P\-Data\-Reader}\label{vtkio_vtkxmlpdatareader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-P\-Data\-Reader provides functionality common to all P\-V\-T\-K X\-M\-L file readers. Concrete subclasses call upon this functionality when needed.

To create an instance of class vtk\-X\-M\-L\-P\-Data\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLPDataReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-P\-Data\-Reader 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\-P\-Data\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Data\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Data\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Pieces ()} -\/ Get the number of pieces from the summary file being read.  
\item {\ttfamily obj.\-Copy\-Output\-Information (vtk\-Information out\-Info, int port)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlpdatasetwriter}{}\section{vtk\-X\-M\-L\-P\-Data\-Set\-Writer}\label{vtkio_vtkxmlpdatasetwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-P\-Data\-Set\-Writer is a wrapper around the P\-V\-T\-K X\-M\-L file format writers. Given an input vtk\-Data\-Set, the correct writer is automatically selected based on the type of input.

To create an instance of class vtk\-X\-M\-L\-P\-Data\-Set\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLPDataSetWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-P\-Data\-Set\-Writer 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\-P\-Data\-Set\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Data\-Set\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Data\-Set\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlpdatawriter}{}\section{vtk\-X\-M\-L\-P\-Data\-Writer}\label{vtkio_vtkxmlpdatawriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-P\-Data\-Writer is the superclass for all X\-M\-L parallel data set writers. It provides functionality needed for writing parallel formats, such as the selection of which writer writes the summary file and what range of pieces are assigned to each serial writer.

To create an instance of class vtk\-X\-M\-L\-P\-Data\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLPDataWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-P\-Data\-Writer 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\-P\-Data\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Data\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Data\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Number\-Of\-Pieces (int )} -\/ Get/\-Set the number of pieces that are being written in parallel.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Pieces ()} -\/ Get/\-Set the number of pieces that are being written in parallel.  
\item {\ttfamily obj.\-Set\-Start\-Piece (int )} -\/ Get/\-Set the range of pieces assigned to this writer.  
\item {\ttfamily int = obj.\-Get\-Start\-Piece ()} -\/ Get/\-Set the range of pieces assigned to this writer.  
\item {\ttfamily obj.\-Set\-End\-Piece (int )} -\/ Get/\-Set the range of pieces assigned to this writer.  
\item {\ttfamily int = obj.\-Get\-End\-Piece ()} -\/ Get/\-Set the range of pieces assigned to this writer.  
\item {\ttfamily obj.\-Set\-Ghost\-Level (int )} -\/ Get/\-Set the ghost level used for this writer's piece.  
\item {\ttfamily int = obj.\-Get\-Ghost\-Level ()} -\/ Get/\-Set the ghost level used for this writer's piece.  
\item {\ttfamily obj.\-Set\-Write\-Summary\-File (int flag)} -\/ Get/\-Set whether this instance of the writer should write the summary file that refers to all of the pieces' individual files. Default is yes only for piece 0 writer.  
\item {\ttfamily int = obj.\-Get\-Write\-Summary\-File ()} -\/ Get/\-Set whether this instance of the writer should write the summary file that refers to all of the pieces' individual files. Default is yes only for piece 0 writer.  
\item {\ttfamily obj.\-Write\-Summary\-File\-On ()} -\/ Get/\-Set whether this instance of the writer should write the summary file that refers to all of the pieces' individual files. Default is yes only for piece 0 writer.  
\item {\ttfamily obj.\-Write\-Summary\-File\-Off ()} -\/ Get/\-Set whether this instance of the writer should write the summary file that refers to all of the pieces' individual files. Default is yes only for piece 0 writer.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlpimagedatareader}{}\section{vtk\-X\-M\-L\-P\-Image\-Data\-Reader}\label{vtkio_vtkxmlpimagedatareader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-P\-Image\-Data\-Reader reads the P\-V\-T\-K X\-M\-L Image\-Data file format. This reads the parallel format's summary file and then uses vtk\-X\-M\-L\-Image\-Data\-Reader to read data from the individual Image\-Data piece files. Streaming is supported. The standard extension for this reader's file format is \char`\"{}pvti\char`\"{}.

To create an instance of class vtk\-X\-M\-L\-P\-Image\-Data\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLPImageDataReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-P\-Image\-Data\-Reader 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\-P\-Image\-Data\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Image\-Data\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Image\-Data\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Output ()} -\/ Get the reader's output.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Output (int idx)} -\/ Get the reader's output.  
\item {\ttfamily obj.\-Copy\-Output\-Information (vtk\-Information out\-Info, int port)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlpimagedatawriter}{}\section{vtk\-X\-M\-L\-P\-Image\-Data\-Writer}\label{vtkio_vtkxmlpimagedatawriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-P\-Image\-Data\-Writer writes the P\-V\-T\-K X\-M\-L Image\-Data file format. One image data input can be written into a parallel file format with any number of pieces spread across files. The standard extension for this writer's file format is \char`\"{}pvti\char`\"{}. This writer uses vtk\-X\-M\-L\-Image\-Data\-Writer to write the individual piece files.

To create an instance of class vtk\-X\-M\-L\-P\-Image\-Data\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLPImageDataWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-P\-Image\-Data\-Writer 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\-P\-Image\-Data\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Image\-Data\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Image\-Data\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily string = obj.\-Get\-Default\-File\-Extension ()} -\/ Get the default file extension for files written by this writer.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlpolydatareader}{}\section{vtk\-X\-M\-L\-Poly\-Data\-Reader}\label{vtkio_vtkxmlpolydatareader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Poly\-Data\-Reader reads the V\-T\-K X\-M\-L Poly\-Data file format. One polygonal data file can be read to produce one output. Streaming is supported. The standard extension for this reader's file format is \char`\"{}vtp\char`\"{}. This reader is also used to read a single piece of the parallel file format.

To create an instance of class vtk\-X\-M\-L\-Poly\-Data\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLPolyDataReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Poly\-Data\-Reader 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\-Poly\-Data\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Poly\-Data\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Poly\-Data\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Output ()} -\/ Get the reader's output.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Output (int idx)} -\/ Get the reader's output.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Verts ()} -\/ Get the number of verts/lines/strips/polys in the output.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Lines ()} -\/ Get the number of verts/lines/strips/polys in the output.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Strips ()} -\/ Get the number of verts/lines/strips/polys in the output.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Polys ()} -\/ Get the number of verts/lines/strips/polys in the output.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlpolydatawriter}{}\section{vtk\-X\-M\-L\-Poly\-Data\-Writer}\label{vtkio_vtkxmlpolydatawriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Poly\-Data\-Writer writes the V\-T\-K X\-M\-L Poly\-Data file format. One polygonal data input can be written into one file in any number of streamed pieces (if supported by the rest of the pipeline). The standard extension for this writer's file format is \char`\"{}vtp\char`\"{}. This writer is also used to write a single piece of the parallel file format.

To create an instance of class vtk\-X\-M\-L\-Poly\-Data\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLPolyDataWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Poly\-Data\-Writer 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\-Poly\-Data\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Poly\-Data\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Poly\-Data\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily string = obj.\-Get\-Default\-File\-Extension ()} -\/ Get the default file extension for files written by this writer.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlppolydatareader}{}\section{vtk\-X\-M\-L\-P\-Poly\-Data\-Reader}\label{vtkio_vtkxmlppolydatareader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-P\-Poly\-Data\-Reader reads the P\-V\-T\-K X\-M\-L Poly\-Data file format. This reads the parallel format's summary file and then uses vtk\-X\-M\-L\-Poly\-Data\-Reader to read data from the individual Poly\-Data piece files. Streaming is supported. The standard extension for this reader's file format is \char`\"{}pvtp\char`\"{}.

To create an instance of class vtk\-X\-M\-L\-P\-Poly\-Data\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLPPolyDataReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-P\-Poly\-Data\-Reader 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\-P\-Poly\-Data\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Poly\-Data\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Poly\-Data\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Output ()} -\/ Get the reader's output.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Output (int idx)} -\/ Get the reader's output.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlppolydatawriter}{}\section{vtk\-X\-M\-L\-P\-Poly\-Data\-Writer}\label{vtkio_vtkxmlppolydatawriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-P\-Poly\-Data\-Writer writes the P\-V\-T\-K X\-M\-L Poly\-Data file format. One poly data input can be written into a parallel file format with any number of pieces spread across files. The standard extension for this writer's file format is \char`\"{}pvtp\char`\"{}. This writer uses vtk\-X\-M\-L\-Poly\-Data\-Writer to write the individual piece files.

To create an instance of class vtk\-X\-M\-L\-P\-Poly\-Data\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLPPolyDataWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-P\-Poly\-Data\-Writer 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\-P\-Poly\-Data\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Poly\-Data\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Poly\-Data\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily string = obj.\-Get\-Default\-File\-Extension ()} -\/ Get the default file extension for files written by this writer.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlprectilineargridreader}{}\section{vtk\-X\-M\-L\-P\-Rectilinear\-Grid\-Reader}\label{vtkio_vtkxmlprectilineargridreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-P\-Rectilinear\-Grid\-Reader reads the P\-V\-T\-K X\-M\-L Rectilinear\-Grid file format. This reads the parallel format's summary file and then uses vtk\-X\-M\-L\-Rectilinear\-Grid\-Reader to read data from the individual Rectilinear\-Grid piece files. Streaming is supported. The standard extension for this reader's file format is \char`\"{}pvtr\char`\"{}.

To create an instance of class vtk\-X\-M\-L\-P\-Rectilinear\-Grid\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLPRectilinearGridReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-P\-Rectilinear\-Grid\-Reader 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\-P\-Rectilinear\-Grid\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Rectilinear\-Grid\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Rectilinear\-Grid\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Rectilinear\-Grid = obj.\-Get\-Output ()} -\/ Get the reader's output.  
\item {\ttfamily vtk\-Rectilinear\-Grid = obj.\-Get\-Output (int idx)} -\/ Get the reader's output.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlprectilineargridwriter}{}\section{vtk\-X\-M\-L\-P\-Rectilinear\-Grid\-Writer}\label{vtkio_vtkxmlprectilineargridwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-P\-Rectilinear\-Grid\-Writer writes the P\-V\-T\-K X\-M\-L Rectilinear\-Grid file format. One rectilinear grid input can be written into a parallel file format with any number of pieces spread across files. The standard extension for this writer's file format is \char`\"{}pvtr\char`\"{}. This writer uses vtk\-X\-M\-L\-Rectilinear\-Grid\-Writer to write the individual piece files.

To create an instance of class vtk\-X\-M\-L\-P\-Rectilinear\-Grid\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLPRectilinearGridWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-P\-Rectilinear\-Grid\-Writer 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\-P\-Rectilinear\-Grid\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Rectilinear\-Grid\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Rectilinear\-Grid\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily string = obj.\-Get\-Default\-File\-Extension ()} -\/ Get the default file extension for files written by this writer.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlpstructureddatareader}{}\section{vtk\-X\-M\-L\-P\-Structured\-Data\-Reader}\label{vtkio_vtkxmlpstructureddatareader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-P\-Structured\-Data\-Reader provides functionality common to all parallel structured data format readers.

To create an instance of class vtk\-X\-M\-L\-P\-Structured\-Data\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLPStructuredDataReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-P\-Structured\-Data\-Reader 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\-P\-Structured\-Data\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Structured\-Data\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Structured\-Data\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Extent\-Translator = obj.\-Get\-Extent\-Translator ()} -\/ Get an extent translator that will create pieces matching the input file's piece breakdown. This can be used further down the pipeline to prevent reading from outside this process's piece. The translator is only valid after an Update\-Information has been called.  
\item {\ttfamily obj.\-Copy\-Output\-Information (vtk\-Information out\-Info, int port)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlpstructureddatawriter}{}\section{vtk\-X\-M\-L\-P\-Structured\-Data\-Writer}\label{vtkio_vtkxmlpstructureddatawriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-P\-Structured\-Data\-Writer provides P\-V\-T\-K X\-M\-L writing functionality that is common among all the parallel structured data formats.

To create an instance of class vtk\-X\-M\-L\-P\-Structured\-Data\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLPStructuredDataWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-P\-Structured\-Data\-Writer 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\-P\-Structured\-Data\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Structured\-Data\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Structured\-Data\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Extent\-Translator (vtk\-Extent\-Translator )} -\/ Get/\-Set the extent translator used for creating pieces.  
\item {\ttfamily vtk\-Extent\-Translator = obj.\-Get\-Extent\-Translator ()} -\/ Get/\-Set the extent translator used for creating pieces.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlpstructuredgridreader}{}\section{vtk\-X\-M\-L\-P\-Structured\-Grid\-Reader}\label{vtkio_vtkxmlpstructuredgridreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-P\-Structured\-Grid\-Reader reads the P\-V\-T\-K X\-M\-L Structured\-Grid file format. This reads the parallel format's summary file and then uses vtk\-X\-M\-L\-Structured\-Grid\-Reader to read data from the individual Structured\-Grid piece files. Streaming is supported. The standard extension for this reader's file format is \char`\"{}pvts\char`\"{}.

To create an instance of class vtk\-X\-M\-L\-P\-Structured\-Grid\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLPStructuredGridReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-P\-Structured\-Grid\-Reader 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\-P\-Structured\-Grid\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Structured\-Grid\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Structured\-Grid\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Structured\-Grid = obj.\-Get\-Output ()} -\/ Get the reader's output.  
\item {\ttfamily vtk\-Structured\-Grid = obj.\-Get\-Output (int idx)} -\/ Needed for Para\-View  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlpstructuredgridwriter}{}\section{vtk\-X\-M\-L\-P\-Structured\-Grid\-Writer}\label{vtkio_vtkxmlpstructuredgridwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-P\-Structured\-Grid\-Writer writes the P\-V\-T\-K X\-M\-L Structured\-Grid file format. One structured grid input can be written into a parallel file format with any number of pieces spread across files. The standard extension for this writer's file format is \char`\"{}pvts\char`\"{}. This writer uses vtk\-X\-M\-L\-Structured\-Grid\-Writer to write the individual piece files.

To create an instance of class vtk\-X\-M\-L\-P\-Structured\-Grid\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLPStructuredGridWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-P\-Structured\-Grid\-Writer 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\-P\-Structured\-Grid\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Structured\-Grid\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Structured\-Grid\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlpunstructureddatareader}{}\section{vtk\-X\-M\-L\-P\-Unstructured\-Data\-Reader}\label{vtkio_vtkxmlpunstructureddatareader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-P\-Unstructured\-Data\-Reader provides functionality common to all parallel unstructured data format readers.

To create an instance of class vtk\-X\-M\-L\-P\-Unstructured\-Data\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLPUnstructuredDataReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-P\-Unstructured\-Data\-Reader 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\-P\-Unstructured\-Data\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Unstructured\-Data\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Unstructured\-Data\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Copy\-Output\-Information (vtk\-Information out\-Info, int port)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlpunstructureddatawriter}{}\section{vtk\-X\-M\-L\-P\-Unstructured\-Data\-Writer}\label{vtkio_vtkxmlpunstructureddatawriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-P\-Unstructured\-Data\-Writer provides P\-V\-T\-K X\-M\-L writing functionality that is common among all the parallel unstructured data formats.

To create an instance of class vtk\-X\-M\-L\-P\-Unstructured\-Data\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLPUnstructuredDataWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-P\-Unstructured\-Data\-Writer 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\-P\-Unstructured\-Data\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Unstructured\-Data\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Unstructured\-Data\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlpunstructuredgridreader}{}\section{vtk\-X\-M\-L\-P\-Unstructured\-Grid\-Reader}\label{vtkio_vtkxmlpunstructuredgridreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-P\-Unstructured\-Grid\-Reader reads the P\-V\-T\-K X\-M\-L Unstructured\-Grid file format. This reads the parallel format's summary file and then uses vtk\-X\-M\-L\-Unstructured\-Grid\-Reader to read data from the individual Unstructured\-Grid piece files. Streaming is supported. The standard extension for this reader's file format is \char`\"{}pvtu\char`\"{}.

To create an instance of class vtk\-X\-M\-L\-P\-Unstructured\-Grid\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLPUnstructuredGridReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-P\-Unstructured\-Grid\-Reader 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\-P\-Unstructured\-Grid\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Unstructured\-Grid\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Unstructured\-Grid\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Unstructured\-Grid = obj.\-Get\-Output ()} -\/ Get the reader's output.  
\item {\ttfamily vtk\-Unstructured\-Grid = obj.\-Get\-Output (int idx)} -\/ Get the reader's output.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlpunstructuredgridwriter}{}\section{vtk\-X\-M\-L\-P\-Unstructured\-Grid\-Writer}\label{vtkio_vtkxmlpunstructuredgridwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-P\-Unstructured\-Grid\-Writer writes the P\-V\-T\-K X\-M\-L Unstructured\-Grid file format. One unstructured grid input can be written into a parallel file format with any number of pieces spread across files. The standard extension for this writer's file format is \char`\"{}pvtu\char`\"{}. This writer uses vtk\-X\-M\-L\-Unstructured\-Grid\-Writer to write the individual piece files.

To create an instance of class vtk\-X\-M\-L\-P\-Unstructured\-Grid\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLPUnstructuredGridWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-P\-Unstructured\-Grid\-Writer 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\-P\-Unstructured\-Grid\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Unstructured\-Grid\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-P\-Unstructured\-Grid\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily string = obj.\-Get\-Default\-File\-Extension ()} -\/ Get the default file extension for files written by this writer.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlreader}{}\section{vtk\-X\-M\-L\-Reader}\label{vtkio_vtkxmlreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Reader uses vtk\-X\-M\-L\-Data\-Parser to parse a V\-T\-K X\-M\-L input file. Concrete subclasses then traverse the parsed file structure and extract data.

To create an instance of class vtk\-X\-M\-L\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Reader 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\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Get/\-Set the name of the input file.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Get/\-Set the name of the input file.  
\item {\ttfamily int = obj.\-Can\-Read\-File (string name)} -\/ Test whether the file with the given name can be read by this reader.  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Output\-As\-Data\-Set ()} -\/ Get the output as a vtk\-Data\-Set pointer.  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Output\-As\-Data\-Set (int index)} -\/ Get the output as a vtk\-Data\-Set pointer.  
\item {\ttfamily vtk\-Data\-Array\-Selection = obj.\-Get\-Point\-Data\-Array\-Selection ()} -\/ Get the data array selection tables used to configure which data arrays are loaded by the reader.  
\item {\ttfamily vtk\-Data\-Array\-Selection = obj.\-Get\-Cell\-Data\-Array\-Selection ()} -\/ Get the data array selection tables used to configure which data arrays are loaded by the reader.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Point\-Arrays ()} -\/ Get the number of point or cell arrays available in the input.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Cell\-Arrays ()} -\/ Get the number of point or cell arrays available in the input.  
\item {\ttfamily string = obj.\-Get\-Point\-Array\-Name (int index)} -\/ Get the name of the point or cell array with the given index in the input.  
\item {\ttfamily string = obj.\-Get\-Cell\-Array\-Name (int index)} -\/ Get the name of the point or cell array with the given index in the input.  
\item {\ttfamily int = obj.\-Get\-Point\-Array\-Status (string name)} -\/ Get/\-Set whether the point or cell array with the given name is to be read.  
\item {\ttfamily int = obj.\-Get\-Cell\-Array\-Status (string name)} -\/ Get/\-Set whether the point or cell array with the given name is to be read.  
\item {\ttfamily obj.\-Set\-Point\-Array\-Status (string name, int status)} -\/ Get/\-Set whether the point or cell array with the given name is to be read.  
\item {\ttfamily obj.\-Set\-Cell\-Array\-Status (string name, int status)} -\/ Get/\-Set whether the point or cell array with the given name is to be read.  
\item {\ttfamily obj.\-Copy\-Output\-Information (vtk\-Information , int )} -\/ Which Time\-Step to read.  
\item {\ttfamily obj.\-Set\-Time\-Step (int )} -\/ Which Time\-Step to read.  
\item {\ttfamily int = obj.\-Get\-Time\-Step ()} -\/ Which Time\-Step to read.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Time\-Steps ()}  
\item {\ttfamily int = obj. Get\-Time\-Step\-Range ()} -\/ Which Time\-Step\-Range to read  
\item {\ttfamily obj.\-Set\-Time\-Step\-Range (int , int )} -\/ Which Time\-Step\-Range to read  
\item {\ttfamily obj.\-Set\-Time\-Step\-Range (int a\mbox{[}2\mbox{]})} -\/ Which Time\-Step\-Range to read  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlrectilineargridreader}{}\section{vtk\-X\-M\-L\-Rectilinear\-Grid\-Reader}\label{vtkio_vtkxmlrectilineargridreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Rectilinear\-Grid\-Reader reads the V\-T\-K X\-M\-L Rectilinear\-Grid file format. One rectilinear grid file can be read to produce one output. Streaming is supported. The standard extension for this reader's file format is \char`\"{}vtr\char`\"{}. This reader is also used to read a single piece of the parallel file format.

To create an instance of class vtk\-X\-M\-L\-Rectilinear\-Grid\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLRectilinearGridReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Rectilinear\-Grid\-Reader 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\-Rectilinear\-Grid\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Rectilinear\-Grid\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Rectilinear\-Grid\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Rectilinear\-Grid = obj.\-Get\-Output ()} -\/ Get the reader's output.  
\item {\ttfamily vtk\-Rectilinear\-Grid = obj.\-Get\-Output (int idx)} -\/ Get the reader's output.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlrectilineargridwriter}{}\section{vtk\-X\-M\-L\-Rectilinear\-Grid\-Writer}\label{vtkio_vtkxmlrectilineargridwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Rectilinear\-Grid\-Writer writes the V\-T\-K X\-M\-L Rectilinear\-Grid file format. One rectilinear grid input can be written into one file in any number of streamed pieces. The standard extension for this writer's file format is \char`\"{}vtr\char`\"{}. This writer is also used to write a single piece of the parallel file format.

To create an instance of class vtk\-X\-M\-L\-Rectilinear\-Grid\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLRectilinearGridWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Rectilinear\-Grid\-Writer 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\-Rectilinear\-Grid\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Rectilinear\-Grid\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Rectilinear\-Grid\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily string = obj.\-Get\-Default\-File\-Extension ()} -\/ Get the default file extension for files written by this writer.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlshader}{}\section{vtk\-X\-M\-L\-Shader}\label{vtkio_vtkxmlshader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Shader encapsulates the X\-M\-L description for a Shader. It provides convenient access to various attributes/properties of a shader. .S\-E\-C\-T\-I\-O\-N Thanks Shader support in V\-T\-K includes key contributions by Gary Templet at Sandia National Labs.

To create an instance of class vtk\-X\-M\-L\-Shader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLShader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Shader 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\-Shader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Shader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Shader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-X\-M\-L\-Data\-Element = obj.\-Get\-Root\-Element ()} -\/ Get/\-Set the X\-M\-L root element that describes this shader.  
\item {\ttfamily obj.\-Set\-Root\-Element (vtk\-X\-M\-L\-Data\-Element )} -\/ Get/\-Set the X\-M\-L root element that describes this shader.  
\item {\ttfamily int = obj.\-Get\-Language ()} -\/ Returns the shader's language as defined in the X\-M\-L description.  
\item {\ttfamily int = obj.\-Get\-Scope ()} -\/ Returns the type of the shader as defined in the X\-M\-L description.  
\item {\ttfamily int = obj.\-Get\-Location ()} -\/ Returns the location of the shader as defined in the X\-M\-L description.  
\item {\ttfamily int = obj.\-Get\-Style ()} -\/ Returns the style of the shader as optionaly defined in the X\-M\-L description. If not present, default style is 1. \char`\"{}style=2\char`\"{} means it is a shader without a main(). In style 2, the \char`\"{}main\char`\"{} function for the vertex shader part is void prop\-Func\-V\-S(void), the main function for the fragment shader part is void prop\-Func\-F\-S(). This is useful when combining a shader at the actor level and a shader defines at the renderer level, like the depth peeling pass. \begin{DoxyPostcond}{Postcondition}
valid\-\_\-result\-: result==1 $|$$|$ result==2  
\end{DoxyPostcond}

\item {\ttfamily string = obj.\-Get\-Name ()} -\/ Get the name of the Shader.  
\item {\ttfamily string = obj.\-Get\-Entry ()} -\/ Get the entry point to the shader code as defined in the X\-M\-L.  
\item {\ttfamily string = obj.\-Get\-Code ()} -\/ Get the shader code.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlstructureddatareader}{}\section{vtk\-X\-M\-L\-Structured\-Data\-Reader}\label{vtkio_vtkxmlstructureddatareader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Structured\-Data\-Reader provides functionality common to all structured data format readers.

To create an instance of class vtk\-X\-M\-L\-Structured\-Data\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLStructuredDataReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Structured\-Data\-Reader 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\-Structured\-Data\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Structured\-Data\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Structured\-Data\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Points ()} -\/ Get the number of points in the output.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Cells ()} -\/ Get the number of cells in the output.  
\item {\ttfamily obj.\-Set\-Whole\-Slices (int )} -\/ Get/\-Set whether the reader gets a whole slice from disk when only a rectangle inside it is needed. This mode reads more data than necessary, but prevents many short reads from interacting poorly with the compression and encoding schemes.  
\item {\ttfamily int = obj.\-Get\-Whole\-Slices ()} -\/ Get/\-Set whether the reader gets a whole slice from disk when only a rectangle inside it is needed. This mode reads more data than necessary, but prevents many short reads from interacting poorly with the compression and encoding schemes.  
\item {\ttfamily obj.\-Whole\-Slices\-On ()} -\/ Get/\-Set whether the reader gets a whole slice from disk when only a rectangle inside it is needed. This mode reads more data than necessary, but prevents many short reads from interacting poorly with the compression and encoding schemes.  
\item {\ttfamily obj.\-Whole\-Slices\-Off ()} -\/ Get/\-Set whether the reader gets a whole slice from disk when only a rectangle inside it is needed. This mode reads more data than necessary, but prevents many short reads from interacting poorly with the compression and encoding schemes.  
\item {\ttfamily obj.\-Copy\-Output\-Information (vtk\-Information out\-Info, int port)} -\/ For the specified port, copy the information this reader sets up in Setup\-Output\-Information to out\-Info  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlstructureddatawriter}{}\section{vtk\-X\-M\-L\-Structured\-Data\-Writer}\label{vtkio_vtkxmlstructureddatawriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Structured\-Data\-Writer provides V\-T\-K X\-M\-L writing functionality that is common among all the structured data formats.

To create an instance of class vtk\-X\-M\-L\-Structured\-Data\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLStructuredDataWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Structured\-Data\-Writer 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\-Structured\-Data\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Structured\-Data\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Structured\-Data\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Number\-Of\-Pieces (int )} -\/ Get/\-Set the number of pieces used to stream the image through the pipeline while writing to the file.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Pieces ()} -\/ Get/\-Set the number of pieces used to stream the image through the pipeline while writing to the file.  
\item {\ttfamily obj.\-Set\-Write\-Extent (int , int , int , int , int , int )} -\/ Get/\-Set the extent of the input that should be treated as the Whole\-Extent in the output file. The default is the Whole\-Extent of the input.  
\item {\ttfamily obj.\-Set\-Write\-Extent (int a\mbox{[}6\mbox{]})} -\/ Get/\-Set the extent of the input that should be treated as the Whole\-Extent in the output file. The default is the Whole\-Extent of the input.  
\item {\ttfamily int = obj. Get\-Write\-Extent ()} -\/ Get/\-Set the extent of the input that should be treated as the Whole\-Extent in the output file. The default is the Whole\-Extent of the input.  
\item {\ttfamily obj.\-Set\-Extent\-Translator (vtk\-Extent\-Translator )} -\/ Get/\-Set the extent translator used for streaming.  
\item {\ttfamily vtk\-Extent\-Translator = obj.\-Get\-Extent\-Translator ()} -\/ Get/\-Set the extent translator used for streaming.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlstructuredgridreader}{}\section{vtk\-X\-M\-L\-Structured\-Grid\-Reader}\label{vtkio_vtkxmlstructuredgridreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Structured\-Grid\-Reader reads the V\-T\-K X\-M\-L Structured\-Grid file format. One structured grid file can be read to produce one output. Streaming is supported. The standard extension for this reader's file format is \char`\"{}vts\char`\"{}. This reader is also used to read a single piece of the parallel file format.

To create an instance of class vtk\-X\-M\-L\-Structured\-Grid\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLStructuredGridReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Structured\-Grid\-Reader 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\-Structured\-Grid\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Structured\-Grid\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Structured\-Grid\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Structured\-Grid = obj.\-Get\-Output ()} -\/ Get the reader's output.  
\item {\ttfamily vtk\-Structured\-Grid = obj.\-Get\-Output (int idx)} -\/ Get the reader's output.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlstructuredgridwriter}{}\section{vtk\-X\-M\-L\-Structured\-Grid\-Writer}\label{vtkio_vtkxmlstructuredgridwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Structured\-Grid\-Writer writes the V\-T\-K X\-M\-L Structured\-Grid file format. One structured grid input can be written into one file in any number of streamed pieces. The standard extension for this writer's file format is \char`\"{}vts\char`\"{}. This writer is also used to write a single piece of the parallel file format.

To create an instance of class vtk\-X\-M\-L\-Structured\-Grid\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLStructuredGridWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Structured\-Grid\-Writer 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\-Structured\-Grid\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Structured\-Grid\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Structured\-Grid\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily string = obj.\-Get\-Default\-File\-Extension ()} -\/ Get the default file extension for files written by this writer.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlunstructureddatareader}{}\section{vtk\-X\-M\-L\-Unstructured\-Data\-Reader}\label{vtkio_vtkxmlunstructureddatareader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Unstructured\-Data\-Reader provides functionality common to all unstructured data format readers.

To create an instance of class vtk\-X\-M\-L\-Unstructured\-Data\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLUnstructuredDataReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Unstructured\-Data\-Reader 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\-Unstructured\-Data\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Unstructured\-Data\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Unstructured\-Data\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Points ()} -\/ Get the number of points in the output.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Cells ()} -\/ Get the number of cells in the output.  
\item {\ttfamily obj.\-Setup\-Update\-Extent (int piece, int number\-Of\-Pieces, int ghost\-Level)} -\/ Setup the reader as if the given update extent were requested by its output. This can be used after an Update\-Information to validate Get\-Number\-Of\-Points() and Get\-Number\-Of\-Cells() without actually reading data.  
\item {\ttfamily obj.\-Copy\-Output\-Information (vtk\-Information out\-Info, int port)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlunstructureddatawriter}{}\section{vtk\-X\-M\-L\-Unstructured\-Data\-Writer}\label{vtkio_vtkxmlunstructureddatawriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Unstructured\-Data\-Writer provides V\-T\-K X\-M\-L writing functionality that is common among all the unstructured data formats.

To create an instance of class vtk\-X\-M\-L\-Unstructured\-Data\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLUnstructuredDataWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Unstructured\-Data\-Writer 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\-Unstructured\-Data\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Unstructured\-Data\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Unstructured\-Data\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Number\-Of\-Pieces (int )} -\/ Get/\-Set the number of pieces used to stream the image through the pipeline while writing to the file.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Pieces ()} -\/ Get/\-Set the number of pieces used to stream the image through the pipeline while writing to the file.  
\item {\ttfamily obj.\-Set\-Write\-Piece (int )} -\/ Get/\-Set the piece to write to the file. If this is negative or equal to the Number\-Of\-Pieces, all pieces will be written.  
\item {\ttfamily int = obj.\-Get\-Write\-Piece ()} -\/ Get/\-Set the piece to write to the file. If this is negative or equal to the Number\-Of\-Pieces, all pieces will be written.  
\item {\ttfamily obj.\-Set\-Ghost\-Level (int )} -\/ Get/\-Set the ghost level used to pad each piece.  
\item {\ttfamily int = obj.\-Get\-Ghost\-Level ()} -\/ Get/\-Set the ghost level used to pad each piece.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlunstructuredgridreader}{}\section{vtk\-X\-M\-L\-Unstructured\-Grid\-Reader}\label{vtkio_vtkxmlunstructuredgridreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Unstructured\-Grid\-Reader reads the V\-T\-K X\-M\-L Unstructured\-Grid file format. One unstructured grid file can be read to produce one output. Streaming is supported. The standard extension for this reader's file format is \char`\"{}vtu\char`\"{}. This reader is also used to read a single piece of the parallel file format.

To create an instance of class vtk\-X\-M\-L\-Unstructured\-Grid\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLUnstructuredGridReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Unstructured\-Grid\-Reader 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\-Unstructured\-Grid\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Unstructured\-Grid\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Unstructured\-Grid\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Unstructured\-Grid = obj.\-Get\-Output ()} -\/ Get the reader's output.  
\item {\ttfamily vtk\-Unstructured\-Grid = obj.\-Get\-Output (int idx)} -\/ Get the reader's output.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlunstructuredgridwriter}{}\section{vtk\-X\-M\-L\-Unstructured\-Grid\-Writer}\label{vtkio_vtkxmlunstructuredgridwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Unstructured\-Grid\-Writer writes the V\-T\-K X\-M\-L Unstructured\-Grid file format. One unstructured grid input can be written into one file in any number of streamed pieces (if supported by the rest of the pipeline). The standard extension for this writer's file format is \char`\"{}vtu\char`\"{}. This writer is also used to write a single piece of the parallel file format.

To create an instance of class vtk\-X\-M\-L\-Unstructured\-Grid\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLUnstructuredGridWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Unstructured\-Grid\-Writer 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\-Unstructured\-Grid\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Unstructured\-Grid\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Unstructured\-Grid\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily string = obj.\-Get\-Default\-File\-Extension ()} -\/ Get the default file extension for files written by this writer.  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlutilities}{}\section{vtk\-X\-M\-L\-Utilities}\label{vtkio_vtkxmlutilities}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Utilities provides X\-M\-L-\/related convenience functions.

To create an instance of class vtk\-X\-M\-L\-Utilities, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLUtilities
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Utilities 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\-Utilities class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Utilities = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Utilities = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkio_vtkxmlwriter}{}\section{vtk\-X\-M\-L\-Writer}\label{vtkio_vtkxmlwriter}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-M\-L\-Writer provides methods implementing most of the functionality needed to write V\-T\-K X\-M\-L file formats. Concrete subclasses provide actual writer implementations calling upon this functionality.

To create an instance of class vtk\-X\-M\-L\-Writer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXMLWriter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-M\-L\-Writer 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\-Writer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-M\-L\-Writer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-M\-L\-Writer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Byte\-Order (int )} -\/ Get/\-Set the byte order of data written to the file. The default is the machine's hardware byte order.  
\item {\ttfamily int = obj.\-Get\-Byte\-Order ()} -\/ Get/\-Set the byte order of data written to the file. The default is the machine's hardware byte order.  
\item {\ttfamily obj.\-Set\-Byte\-Order\-To\-Big\-Endian ()} -\/ Get/\-Set the byte order of data written to the file. The default is the machine's hardware byte order.  
\item {\ttfamily obj.\-Set\-Byte\-Order\-To\-Little\-Endian ()} -\/ Get/\-Set the byte order of data written to the file. The default is the machine's hardware byte order.  
\item {\ttfamily obj.\-Set\-Id\-Type (int )} -\/ Get/\-Set the size of the vtk\-Id\-Type values stored in the file. The default is the real size of vtk\-Id\-Type.  
\item {\ttfamily int = obj.\-Get\-Id\-Type ()} -\/ Get/\-Set the size of the vtk\-Id\-Type values stored in the file. The default is the real size of vtk\-Id\-Type.  
\item {\ttfamily obj.\-Set\-Id\-Type\-To\-Int32 ()} -\/ Get/\-Set the size of the vtk\-Id\-Type values stored in the file. The default is the real size of vtk\-Id\-Type.  
\item {\ttfamily obj.\-Set\-Id\-Type\-To\-Int64 ()} -\/ Get/\-Set the size of the vtk\-Id\-Type values stored in the file. The default is the real size of vtk\-Id\-Type.  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Get/\-Set the name of the output file.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Get/\-Set the name of the output file.  
\item {\ttfamily obj.\-Set\-Compressor (vtk\-Data\-Compressor )} -\/ Get/\-Set the compressor used to compress binary and appended data before writing to the file. Default is a vtk\-Z\-Lib\-Data\-Compressor.  
\item {\ttfamily vtk\-Data\-Compressor = obj.\-Get\-Compressor ()} -\/ Get/\-Set the compressor used to compress binary and appended data before writing to the file. Default is a vtk\-Z\-Lib\-Data\-Compressor.  
\item {\ttfamily obj.\-Set\-Compressor\-Type (int compressor\-Type)} -\/ Convenience functions to set the compressor to certain known types.  
\item {\ttfamily obj.\-Set\-Compressor\-Type\-To\-None ()} -\/ Convenience functions to set the compressor to certain known types.  
\item {\ttfamily obj.\-Set\-Compressor\-Type\-To\-Z\-Lib ()} -\/ Get/\-Set the block size used in compression. When reading, this controls the granularity of how much extra information must be read when only part of the data are requested. The value should be a multiple of the largest scalar data type.  
\item {\ttfamily obj.\-Set\-Block\-Size (int block\-Size)} -\/ Get/\-Set the block size used in compression. When reading, this controls the granularity of how much extra information must be read when only part of the data are requested. The value should be a multiple of the largest scalar data type.  
\item {\ttfamily int = obj.\-Get\-Block\-Size ()} -\/ Get/\-Set the block size used in compression. When reading, this controls the granularity of how much extra information must be read when only part of the data are requested. The value should be a multiple of the largest scalar data type.  
\item {\ttfamily obj.\-Set\-Data\-Mode (int )} -\/ Get/\-Set the data mode used for the file's data. The options are vtk\-X\-M\-L\-Writer\-::\-Ascii, vtk\-X\-M\-L\-Writer\-::\-Binary, and vtk\-X\-M\-L\-Writer\-::\-Appended.  
\item {\ttfamily int = obj.\-Get\-Data\-Mode ()} -\/ Get/\-Set the data mode used for the file's data. The options are vtk\-X\-M\-L\-Writer\-::\-Ascii, vtk\-X\-M\-L\-Writer\-::\-Binary, and vtk\-X\-M\-L\-Writer\-::\-Appended.  
\item {\ttfamily obj.\-Set\-Data\-Mode\-To\-Ascii ()} -\/ Get/\-Set the data mode used for the file's data. The options are vtk\-X\-M\-L\-Writer\-::\-Ascii, vtk\-X\-M\-L\-Writer\-::\-Binary, and vtk\-X\-M\-L\-Writer\-::\-Appended.  
\item {\ttfamily obj.\-Set\-Data\-Mode\-To\-Binary ()} -\/ Get/\-Set the data mode used for the file's data. The options are vtk\-X\-M\-L\-Writer\-::\-Ascii, vtk\-X\-M\-L\-Writer\-::\-Binary, and vtk\-X\-M\-L\-Writer\-::\-Appended.  
\item {\ttfamily obj.\-Set\-Data\-Mode\-To\-Appended ()} -\/ Get/\-Set the data mode used for the file's data. The options are vtk\-X\-M\-L\-Writer\-::\-Ascii, vtk\-X\-M\-L\-Writer\-::\-Binary, and vtk\-X\-M\-L\-Writer\-::\-Appended.  
\item {\ttfamily obj.\-Set\-Encode\-Appended\-Data (int )} -\/ Get/\-Set whether the appended data section is base64 encoded. If encoded, reading and writing will be slower, but the file will be fully valid X\-M\-L and text-\/only. If not encoded, the X\-M\-L specification will be violated, but reading and writing will be fast. The default is to do the encoding.  
\item {\ttfamily int = obj.\-Get\-Encode\-Appended\-Data ()} -\/ Get/\-Set whether the appended data section is base64 encoded. If encoded, reading and writing will be slower, but the file will be fully valid X\-M\-L and text-\/only. If not encoded, the X\-M\-L specification will be violated, but reading and writing will be fast. The default is to do the encoding.  
\item {\ttfamily obj.\-Encode\-Appended\-Data\-On ()} -\/ Get/\-Set whether the appended data section is base64 encoded. If encoded, reading and writing will be slower, but the file will be fully valid X\-M\-L and text-\/only. If not encoded, the X\-M\-L specification will be violated, but reading and writing will be fast. The default is to do the encoding.  
\item {\ttfamily obj.\-Encode\-Appended\-Data\-Off ()} -\/ Get/\-Set whether the appended data section is base64 encoded. If encoded, reading and writing will be slower, but the file will be fully valid X\-M\-L and text-\/only. If not encoded, the X\-M\-L specification will be violated, but reading and writing will be fast. The default is to do the encoding.  
\item {\ttfamily obj.\-Set\-Input (vtk\-Data\-Object )} -\/ Set/\-Get an input of this algorithm. You should not override these methods because they are not the only way to connect a pipeline  
\item {\ttfamily obj.\-Set\-Input (int , vtk\-Data\-Object )} -\/ Set/\-Get an input of this algorithm. You should not override these methods because they are not the only way to connect a pipeline  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Input (int port)} -\/ Set/\-Get an input of this algorithm. You should not override these methods because they are not the only way to connect a pipeline  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Input ()} -\/ Set/\-Get an input of this algorithm. You should not override these methods because they are not the only way to connect a pipeline  
\item {\ttfamily string = obj.\-Get\-Default\-File\-Extension ()} -\/ Get the default file extension for files written by this writer.  
\item {\ttfamily int = obj.\-Write ()} -\/ Invoke the writer. Returns 1 for success, 0 for failure.  
\item {\ttfamily obj.\-Set\-Time\-Step (int )} -\/ Which Time\-Step to write.  
\item {\ttfamily int = obj.\-Get\-Time\-Step ()} -\/ Which Time\-Step to write.  
\item {\ttfamily int = obj. Get\-Time\-Step\-Range ()} -\/ Which Time\-Step\-Range to write.  
\item {\ttfamily obj.\-Set\-Time\-Step\-Range (int , int )} -\/ Which Time\-Step\-Range to write.  
\item {\ttfamily obj.\-Set\-Time\-Step\-Range (int a\mbox{[}2\mbox{]})} -\/ Which Time\-Step\-Range to write.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Time\-Steps ()} -\/ Set the number of time steps  
\item {\ttfamily obj.\-Set\-Number\-Of\-Time\-Steps (int )} -\/ Set the number of time steps  
\item {\ttfamily obj.\-Start ()} -\/ A\-P\-I to interface an outside the V\-T\-K pipeline control  
\item {\ttfamily obj.\-Stop ()} -\/ A\-P\-I to interface an outside the V\-T\-K pipeline control  
\item {\ttfamily obj.\-Write\-Next\-Time (double time)} -\/ A\-P\-I to interface an outside the V\-T\-K pipeline control  
\end{DoxyItemize}\hypertarget{vtkio_vtkxyzmolreader}{}\section{vtk\-X\-Y\-Z\-Mol\-Reader}\label{vtkio_vtkxyzmolreader}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-Y\-Z\-Mol\-Reader is a source object that reads Molecule files The File\-Name must be specified

.S\-E\-C\-T\-I\-O\-N Thanks Dr. Jean M. Favre who developed and contributed this class

To create an instance of class vtk\-X\-Y\-Z\-Mol\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXYZMolReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-Y\-Z\-Mol\-Reader 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\-Y\-Z\-Mol\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-Y\-Z\-Mol\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-Y\-Z\-Mol\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Can\-Read\-File (string name)} -\/ Test whether the file with the given name can be read by this reader.  
\item {\ttfamily obj.\-Set\-Time\-Step (int )} -\/ Set the current time step. It should be greater than 0 and smaller than Max\-Time\-Step.  
\item {\ttfamily int = obj.\-Get\-Time\-Step ()} -\/ Set the current time step. It should be greater than 0 and smaller than Max\-Time\-Step.  
\item {\ttfamily int = obj.\-Get\-Max\-Time\-Step ()} -\/ Get the maximum time step.  
\end{DoxyItemize}\hypertarget{vtkio_vtkzlibdatacompressor}{}\section{vtk\-Z\-Lib\-Data\-Compressor}\label{vtkio_vtkzlibdatacompressor}
Section\-: \hyperlink{sec_vtkio}{Visualization Toolkit I\-O Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Z\-Lib\-Data\-Compressor provides a concrete vtk\-Data\-Compressor class using zlib for compressing and uncompressing data.

To create an instance of class vtk\-Z\-Lib\-Data\-Compressor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkZLibDataCompressor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Z\-Lib\-Data\-Compressor 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\-Z\-Lib\-Data\-Compressor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Z\-Lib\-Data\-Compressor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Z\-Lib\-Data\-Compressor = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily long = obj.\-Get\-Maximum\-Compression\-Space (long size)} -\/ Get the maximum space that may be needed to store data of the given uncompressed size after compression. This is the minimum size of the output buffer that can be passed to the four-\/argument Compress method.  
\item {\ttfamily obj.\-Set\-Compression\-Level (int )} -\/ Get/\-Set the compression level.  
\item {\ttfamily int = obj.\-Get\-Compression\-Level\-Min\-Value ()} -\/ Get/\-Set the compression level.  
\item {\ttfamily int = obj.\-Get\-Compression\-Level\-Max\-Value ()} -\/ Get/\-Set the compression level.  
\item {\ttfamily int = obj.\-Get\-Compression\-Level ()} -\/ Get/\-Set the compression level.  
\end{DoxyItemize}