
\begin{DoxyItemize}
\item \hyperlink{vtkgraphics_vtkannotationlink}{vtk\-Annotation\-Link}  
\item \hyperlink{vtkgraphics_vtkappendcompositedataleaves}{vtk\-Append\-Composite\-Data\-Leaves}  
\item \hyperlink{vtkgraphics_vtkappendfilter}{vtk\-Append\-Filter}  
\item \hyperlink{vtkgraphics_vtkappendpolydata}{vtk\-Append\-Poly\-Data}  
\item \hyperlink{vtkgraphics_vtkappendselection}{vtk\-Append\-Selection}  
\item \hyperlink{vtkgraphics_vtkapproximatingsubdivisionfilter}{vtk\-Approximating\-Subdivision\-Filter}  
\item \hyperlink{vtkgraphics_vtkarcsource}{vtk\-Arc\-Source}  
\item \hyperlink{vtkgraphics_vtkarraycalculator}{vtk\-Array\-Calculator}  
\item \hyperlink{vtkgraphics_vtkarrowsource}{vtk\-Arrow\-Source}  
\item \hyperlink{vtkgraphics_vtkassignattribute}{vtk\-Assign\-Attribute}  
\item \hyperlink{vtkgraphics_vtkattributedatatofielddatafilter}{vtk\-Attribute\-Data\-To\-Field\-Data\-Filter}  
\item \hyperlink{vtkgraphics_vtkaxes}{vtk\-Axes}  
\item \hyperlink{vtkgraphics_vtkbandedpolydatacontourfilter}{vtk\-Banded\-Poly\-Data\-Contour\-Filter}  
\item \hyperlink{vtkgraphics_vtkblankstructuredgrid}{vtk\-Blank\-Structured\-Grid}  
\item \hyperlink{vtkgraphics_vtkblankstructuredgridwithimage}{vtk\-Blank\-Structured\-Grid\-With\-Image}  
\item \hyperlink{vtkgraphics_vtkblockidscalars}{vtk\-Block\-Id\-Scalars}  
\item \hyperlink{vtkgraphics_vtkboxclipdataset}{vtk\-Box\-Clip\-Data\-Set}  
\item \hyperlink{vtkgraphics_vtkbrownianpoints}{vtk\-Brownian\-Points}  
\item \hyperlink{vtkgraphics_vtkbutterflysubdivisionfilter}{vtk\-Butterfly\-Subdivision\-Filter}  
\item \hyperlink{vtkgraphics_vtkbuttonsource}{vtk\-Button\-Source}  
\item \hyperlink{vtkgraphics_vtkcellcenters}{vtk\-Cell\-Centers}  
\item \hyperlink{vtkgraphics_vtkcelldatatopointdata}{vtk\-Cell\-Data\-To\-Point\-Data}  
\item \hyperlink{vtkgraphics_vtkcellderivatives}{vtk\-Cell\-Derivatives}  
\item \hyperlink{vtkgraphics_vtkcleanpolydata}{vtk\-Clean\-Poly\-Data}  
\item \hyperlink{vtkgraphics_vtkclipconvexpolydata}{vtk\-Clip\-Convex\-Poly\-Data}  
\item \hyperlink{vtkgraphics_vtkclipdataset}{vtk\-Clip\-Data\-Set}  
\item \hyperlink{vtkgraphics_vtkcliphyperoctree}{vtk\-Clip\-Hyper\-Octree}  
\item \hyperlink{vtkgraphics_vtkclippolydata}{vtk\-Clip\-Poly\-Data}  
\item \hyperlink{vtkgraphics_vtkclipvolume}{vtk\-Clip\-Volume}  
\item \hyperlink{vtkgraphics_vtkcoincidentpoints}{vtk\-Coincident\-Points}  
\item \hyperlink{vtkgraphics_vtkcompositedatageometryfilter}{vtk\-Composite\-Data\-Geometry\-Filter}  
\item \hyperlink{vtkgraphics_vtkcompositedataprobefilter}{vtk\-Composite\-Data\-Probe\-Filter}  
\item \hyperlink{vtkgraphics_vtkconesource}{vtk\-Cone\-Source}  
\item \hyperlink{vtkgraphics_vtkconnectivityfilter}{vtk\-Connectivity\-Filter}  
\item \hyperlink{vtkgraphics_vtkcontourfilter}{vtk\-Contour\-Filter}  
\item \hyperlink{vtkgraphics_vtkcontourgrid}{vtk\-Contour\-Grid}  
\item \hyperlink{vtkgraphics_vtkconvertselection}{vtk\-Convert\-Selection}  
\item \hyperlink{vtkgraphics_vtkcubesource}{vtk\-Cube\-Source}  
\item \hyperlink{vtkgraphics_vtkcursor2d}{vtk\-Cursor2\-D}  
\item \hyperlink{vtkgraphics_vtkcursor3d}{vtk\-Cursor3\-D}  
\item \hyperlink{vtkgraphics_vtkcurvatures}{vtk\-Curvatures}  
\item \hyperlink{vtkgraphics_vtkcutter}{vtk\-Cutter}  
\item \hyperlink{vtkgraphics_vtkcylindersource}{vtk\-Cylinder\-Source}  
\item \hyperlink{vtkgraphics_vtkdashedstreamline}{vtk\-Dashed\-Stream\-Line}  
\item \hyperlink{vtkgraphics_vtkdataobjectgenerator}{vtk\-Data\-Object\-Generator}  
\item \hyperlink{vtkgraphics_vtkdataobjecttodatasetfilter}{vtk\-Data\-Object\-To\-Data\-Set\-Filter}  
\item \hyperlink{vtkgraphics_vtkdatasetedgesubdivisioncriterion}{vtk\-Data\-Set\-Edge\-Subdivision\-Criterion}  
\item \hyperlink{vtkgraphics_vtkdatasetgradient}{vtk\-Data\-Set\-Gradient}  
\item \hyperlink{vtkgraphics_vtkdatasetgradientprecompute}{vtk\-Data\-Set\-Gradient\-Precompute}  
\item \hyperlink{vtkgraphics_vtkdatasetsurfacefilter}{vtk\-Data\-Set\-Surface\-Filter}  
\item \hyperlink{vtkgraphics_vtkdatasettodataobjectfilter}{vtk\-Data\-Set\-To\-Data\-Object\-Filter}  
\item \hyperlink{vtkgraphics_vtkdatasettrianglefilter}{vtk\-Data\-Set\-Triangle\-Filter}  
\item \hyperlink{vtkgraphics_vtkdecimatepolylinefilter}{vtk\-Decimate\-Polyline\-Filter}  
\item \hyperlink{vtkgraphics_vtkdecimatepro}{vtk\-Decimate\-Pro}  
\item \hyperlink{vtkgraphics_vtkdelaunay2d}{vtk\-Delaunay2\-D}  
\item \hyperlink{vtkgraphics_vtkdelaunay3d}{vtk\-Delaunay3\-D}  
\item \hyperlink{vtkgraphics_vtkdensifypolydata}{vtk\-Densify\-Poly\-Data}  
\item \hyperlink{vtkgraphics_vtkdicer}{vtk\-Dicer}  
\item \hyperlink{vtkgraphics_vtkdijkstragraphgeodesicpath}{vtk\-Dijkstra\-Graph\-Geodesic\-Path}  
\item \hyperlink{vtkgraphics_vtkdijkstraimagegeodesicpath}{vtk\-Dijkstra\-Image\-Geodesic\-Path}  
\item \hyperlink{vtkgraphics_vtkdiscretemarchingcubes}{vtk\-Discrete\-Marching\-Cubes}  
\item \hyperlink{vtkgraphics_vtkdisksource}{vtk\-Disk\-Source}  
\item \hyperlink{vtkgraphics_vtkedgepoints}{vtk\-Edge\-Points}  
\item \hyperlink{vtkgraphics_vtkedgesubdivisioncriterion}{vtk\-Edge\-Subdivision\-Criterion}  
\item \hyperlink{vtkgraphics_vtkelevationfilter}{vtk\-Elevation\-Filter}  
\item \hyperlink{vtkgraphics_vtkellipticalbuttonsource}{vtk\-Elliptical\-Button\-Source}  
\item \hyperlink{vtkgraphics_vtkextractarraysovertime}{vtk\-Extract\-Arrays\-Over\-Time}  
\item \hyperlink{vtkgraphics_vtkextractblock}{vtk\-Extract\-Block}  
\item \hyperlink{vtkgraphics_vtkextractcells}{vtk\-Extract\-Cells}  
\item \hyperlink{vtkgraphics_vtkextractdataovertime}{vtk\-Extract\-Data\-Over\-Time}  
\item \hyperlink{vtkgraphics_vtkextractdatasets}{vtk\-Extract\-Data\-Sets}  
\item \hyperlink{vtkgraphics_vtkextractedges}{vtk\-Extract\-Edges}  
\item \hyperlink{vtkgraphics_vtkextractgeometry}{vtk\-Extract\-Geometry}  
\item \hyperlink{vtkgraphics_vtkextractgrid}{vtk\-Extract\-Grid}  
\item \hyperlink{vtkgraphics_vtkextractlevel}{vtk\-Extract\-Level}  
\item \hyperlink{vtkgraphics_vtkextractpolydatageometry}{vtk\-Extract\-Poly\-Data\-Geometry}  
\item \hyperlink{vtkgraphics_vtkextractrectilineargrid}{vtk\-Extract\-Rectilinear\-Grid}  
\item \hyperlink{vtkgraphics_vtkextractselectedblock}{vtk\-Extract\-Selected\-Block}  
\item \hyperlink{vtkgraphics_vtkextractselectedfrustum}{vtk\-Extract\-Selected\-Frustum}  
\item \hyperlink{vtkgraphics_vtkextractselectedids}{vtk\-Extract\-Selected\-Ids}  
\item \hyperlink{vtkgraphics_vtkextractselectedlocations}{vtk\-Extract\-Selected\-Locations}  
\item \hyperlink{vtkgraphics_vtkextractselectedpolydataids}{vtk\-Extract\-Selected\-Poly\-Data\-Ids}  
\item \hyperlink{vtkgraphics_vtkextractselectedrows}{vtk\-Extract\-Selected\-Rows}  
\item \hyperlink{vtkgraphics_vtkextractselectedthresholds}{vtk\-Extract\-Selected\-Thresholds}  
\item \hyperlink{vtkgraphics_vtkextractselection}{vtk\-Extract\-Selection}  
\item \hyperlink{vtkgraphics_vtkextractselectionbase}{vtk\-Extract\-Selection\-Base}  
\item \hyperlink{vtkgraphics_vtkextracttemporalfielddata}{vtk\-Extract\-Temporal\-Field\-Data}  
\item \hyperlink{vtkgraphics_vtkextracttensorcomponents}{vtk\-Extract\-Tensor\-Components}  
\item \hyperlink{vtkgraphics_vtkextractunstructuredgrid}{vtk\-Extract\-Unstructured\-Grid}  
\item \hyperlink{vtkgraphics_vtkextractvectorcomponents}{vtk\-Extract\-Vector\-Components}  
\item \hyperlink{vtkgraphics_vtkfeatureedges}{vtk\-Feature\-Edges}  
\item \hyperlink{vtkgraphics_vtkfielddatatoattributedatafilter}{vtk\-Field\-Data\-To\-Attribute\-Data\-Filter}  
\item \hyperlink{vtkgraphics_vtkfillholesfilter}{vtk\-Fill\-Holes\-Filter}  
\item \hyperlink{vtkgraphics_vtkfrustumsource}{vtk\-Frustum\-Source}  
\item \hyperlink{vtkgraphics_vtkgeodesicpath}{vtk\-Geodesic\-Path}  
\item \hyperlink{vtkgraphics_vtkgeometryfilter}{vtk\-Geometry\-Filter}  
\item \hyperlink{vtkgraphics_vtkglyph2d}{vtk\-Glyph2\-D}  
\item \hyperlink{vtkgraphics_vtkglyph3d}{vtk\-Glyph3\-D}  
\item \hyperlink{vtkgraphics_vtkglyphsource2d}{vtk\-Glyph\-Source2\-D}  
\item \hyperlink{vtkgraphics_vtkgradientfilter}{vtk\-Gradient\-Filter}  
\item \hyperlink{vtkgraphics_vtkgraphgeodesicpath}{vtk\-Graph\-Geodesic\-Path}  
\item \hyperlink{vtkgraphics_vtkgraphlayoutfilter}{vtk\-Graph\-Layout\-Filter}  
\item \hyperlink{vtkgraphics_vtkgraphtopoints}{vtk\-Graph\-To\-Points}  
\item \hyperlink{vtkgraphics_vtkgraphtopolydata}{vtk\-Graph\-To\-Poly\-Data}  
\item \hyperlink{vtkgraphics_vtkgridsynchronizedtemplates3d}{vtk\-Grid\-Synchronized\-Templates3\-D}  
\item \hyperlink{vtkgraphics_vtkhedgehog}{vtk\-Hedge\-Hog}  
\item \hyperlink{vtkgraphics_vtkhierarchicaldataextractdatasets}{vtk\-Hierarchical\-Data\-Extract\-Data\-Sets}  
\item \hyperlink{vtkgraphics_vtkhierarchicaldataextractlevel}{vtk\-Hierarchical\-Data\-Extract\-Level}  
\item \hyperlink{vtkgraphics_vtkhierarchicaldatalevelfilter}{vtk\-Hierarchical\-Data\-Level\-Filter}  
\item \hyperlink{vtkgraphics_vtkhierarchicaldatasetgeometryfilter}{vtk\-Hierarchical\-Data\-Set\-Geometry\-Filter}  
\item \hyperlink{vtkgraphics_vtkhull}{vtk\-Hull}  
\item \hyperlink{vtkgraphics_vtkhyperoctreecontourfilter}{vtk\-Hyper\-Octree\-Contour\-Filter}  
\item \hyperlink{vtkgraphics_vtkhyperoctreecutter}{vtk\-Hyper\-Octree\-Cutter}  
\item \hyperlink{vtkgraphics_vtkhyperoctreedepth}{vtk\-Hyper\-Octree\-Depth}  
\item \hyperlink{vtkgraphics_vtkhyperoctreedualgridcontourfilter}{vtk\-Hyper\-Octree\-Dual\-Grid\-Contour\-Filter}  
\item \hyperlink{vtkgraphics_vtkhyperoctreefractalsource}{vtk\-Hyper\-Octree\-Fractal\-Source}  
\item \hyperlink{vtkgraphics_vtkhyperoctreelimiter}{vtk\-Hyper\-Octree\-Limiter}  
\item \hyperlink{vtkgraphics_vtkhyperoctreesamplefunction}{vtk\-Hyper\-Octree\-Sample\-Function}  
\item \hyperlink{vtkgraphics_vtkhyperoctreesurfacefilter}{vtk\-Hyper\-Octree\-Surface\-Filter}  
\item \hyperlink{vtkgraphics_vtkhyperoctreetouniformgridfilter}{vtk\-Hyper\-Octree\-To\-Uniform\-Grid\-Filter}  
\item \hyperlink{vtkgraphics_vtkhyperstreamline}{vtk\-Hyper\-Streamline}  
\item \hyperlink{vtkgraphics_vtkiconglyphfilter}{vtk\-Icon\-Glyph\-Filter}  
\item \hyperlink{vtkgraphics_vtkidfilter}{vtk\-Id\-Filter}  
\item \hyperlink{vtkgraphics_vtkimagedatageometryfilter}{vtk\-Image\-Data\-Geometry\-Filter}  
\item \hyperlink{vtkgraphics_vtkimagemarchingcubes}{vtk\-Image\-Marching\-Cubes}  
\item \hyperlink{vtkgraphics_vtkimplicittexturecoords}{vtk\-Implicit\-Texture\-Coords}  
\item \hyperlink{vtkgraphics_vtkinterpolatedatasetattributes}{vtk\-Interpolate\-Data\-Set\-Attributes}  
\item \hyperlink{vtkgraphics_vtkinterpolatingsubdivisionfilter}{vtk\-Interpolating\-Subdivision\-Filter}  
\item \hyperlink{vtkgraphics_vtkkdtreeselector}{vtk\-Kd\-Tree\-Selector}  
\item \hyperlink{vtkgraphics_vtklevelidscalars}{vtk\-Level\-Id\-Scalars}  
\item \hyperlink{vtkgraphics_vtklinearextrusionfilter}{vtk\-Linear\-Extrusion\-Filter}  
\item \hyperlink{vtkgraphics_vtklinearsubdivisionfilter}{vtk\-Linear\-Subdivision\-Filter}  
\item \hyperlink{vtkgraphics_vtklinesource}{vtk\-Line\-Source}  
\item \hyperlink{vtkgraphics_vtklinkedgels}{vtk\-Link\-Edgels}  
\item \hyperlink{vtkgraphics_vtkloopsubdivisionfilter}{vtk\-Loop\-Subdivision\-Filter}  
\item \hyperlink{vtkgraphics_vtkmarchingcontourfilter}{vtk\-Marching\-Contour\-Filter}  
\item \hyperlink{vtkgraphics_vtkmarchingcubes}{vtk\-Marching\-Cubes}  
\item \hyperlink{vtkgraphics_vtkmarchingsquares}{vtk\-Marching\-Squares}  
\item \hyperlink{vtkgraphics_vtkmaskfields}{vtk\-Mask\-Fields}  
\item \hyperlink{vtkgraphics_vtkmaskpoints}{vtk\-Mask\-Points}  
\item \hyperlink{vtkgraphics_vtkmaskpolydata}{vtk\-Mask\-Poly\-Data}  
\item \hyperlink{vtkgraphics_vtkmassproperties}{vtk\-Mass\-Properties}  
\item \hyperlink{vtkgraphics_vtkmergecells}{vtk\-Merge\-Cells}  
\item \hyperlink{vtkgraphics_vtkmergedataobjectfilter}{vtk\-Merge\-Data\-Object\-Filter}  
\item \hyperlink{vtkgraphics_vtkmergefields}{vtk\-Merge\-Fields}  
\item \hyperlink{vtkgraphics_vtkmergefilter}{vtk\-Merge\-Filter}  
\item \hyperlink{vtkgraphics_vtkmeshquality}{vtk\-Mesh\-Quality}  
\item \hyperlink{vtkgraphics_vtkmodelmetadata}{vtk\-Model\-Metadata}  
\item \hyperlink{vtkgraphics_vtkmultiblockdatagroupfilter}{vtk\-Multi\-Block\-Data\-Group\-Filter}  
\item \hyperlink{vtkgraphics_vtkmultiblockmergefilter}{vtk\-Multi\-Block\-Merge\-Filter}  
\item \hyperlink{vtkgraphics_vtkmultithreshold}{vtk\-Multi\-Threshold}  
\item \hyperlink{vtkgraphics_vtkobbdicer}{vtk\-O\-B\-B\-Dicer}  
\item \hyperlink{vtkgraphics_vtkobbtree}{vtk\-O\-B\-B\-Tree}  
\item \hyperlink{vtkgraphics_vtkoutlinecornerfilter}{vtk\-Outline\-Corner\-Filter}  
\item \hyperlink{vtkgraphics_vtkoutlinecornersource}{vtk\-Outline\-Corner\-Source}  
\item \hyperlink{vtkgraphics_vtkoutlinefilter}{vtk\-Outline\-Filter}  
\item \hyperlink{vtkgraphics_vtkoutlinesource}{vtk\-Outline\-Source}  
\item \hyperlink{vtkgraphics_vtkparametricfunctionsource}{vtk\-Parametric\-Function\-Source}  
\item \hyperlink{vtkgraphics_vtkplanesource}{vtk\-Plane\-Source}  
\item \hyperlink{vtkgraphics_vtkplatonicsolidsource}{vtk\-Platonic\-Solid\-Source}  
\item \hyperlink{vtkgraphics_vtkpointdatatocelldata}{vtk\-Point\-Data\-To\-Cell\-Data}  
\item \hyperlink{vtkgraphics_vtkpointsource}{vtk\-Point\-Source}  
\item \hyperlink{vtkgraphics_vtkpolydataconnectivityfilter}{vtk\-Poly\-Data\-Connectivity\-Filter}  
\item \hyperlink{vtkgraphics_vtkpolydatanormals}{vtk\-Poly\-Data\-Normals}  
\item \hyperlink{vtkgraphics_vtkpolydatapointsampler}{vtk\-Poly\-Data\-Point\-Sampler}  
\item \hyperlink{vtkgraphics_vtkpolydatastreamer}{vtk\-Poly\-Data\-Streamer}  
\item \hyperlink{vtkgraphics_vtkprobefilter}{vtk\-Probe\-Filter}  
\item \hyperlink{vtkgraphics_vtkprobeselectedlocations}{vtk\-Probe\-Selected\-Locations}  
\item \hyperlink{vtkgraphics_vtkprogrammableattributedatafilter}{vtk\-Programmable\-Attribute\-Data\-Filter}  
\item \hyperlink{vtkgraphics_vtkprogrammabledataobjectsource}{vtk\-Programmable\-Data\-Object\-Source}  
\item \hyperlink{vtkgraphics_vtkprogrammablefilter}{vtk\-Programmable\-Filter}  
\item \hyperlink{vtkgraphics_vtkprogrammableglyphfilter}{vtk\-Programmable\-Glyph\-Filter}  
\item \hyperlink{vtkgraphics_vtkprogrammablesource}{vtk\-Programmable\-Source}  
\item \hyperlink{vtkgraphics_vtkprojectedtexture}{vtk\-Projected\-Texture}  
\item \hyperlink{vtkgraphics_vtkquadraturepointinterpolator}{vtk\-Quadrature\-Point\-Interpolator}  
\item \hyperlink{vtkgraphics_vtkquadraturepointsgenerator}{vtk\-Quadrature\-Points\-Generator}  
\item \hyperlink{vtkgraphics_vtkquadratureschemedictionarygenerator}{vtk\-Quadrature\-Scheme\-Dictionary\-Generator}  
\item \hyperlink{vtkgraphics_vtkquadricclustering}{vtk\-Quadric\-Clustering}  
\item \hyperlink{vtkgraphics_vtkquadricdecimation}{vtk\-Quadric\-Decimation}  
\item \hyperlink{vtkgraphics_vtkquantizepolydatapoints}{vtk\-Quantize\-Poly\-Data\-Points}  
\item \hyperlink{vtkgraphics_vtkrandomattributegenerator}{vtk\-Random\-Attribute\-Generator}  
\item \hyperlink{vtkgraphics_vtkrearrangefields}{vtk\-Rearrange\-Fields}  
\item \hyperlink{vtkgraphics_vtkrectangularbuttonsource}{vtk\-Rectangular\-Button\-Source}  
\item \hyperlink{vtkgraphics_vtkrectilineargridclip}{vtk\-Rectilinear\-Grid\-Clip}  
\item \hyperlink{vtkgraphics_vtkrectilineargridgeometryfilter}{vtk\-Rectilinear\-Grid\-Geometry\-Filter}  
\item \hyperlink{vtkgraphics_vtkrectilineargridtotetrahedra}{vtk\-Rectilinear\-Grid\-To\-Tetrahedra}  
\item \hyperlink{vtkgraphics_vtkrectilinearsynchronizedtemplates}{vtk\-Rectilinear\-Synchronized\-Templates}  
\item \hyperlink{vtkgraphics_vtkrecursivedividingcubes}{vtk\-Recursive\-Dividing\-Cubes}  
\item \hyperlink{vtkgraphics_vtkreflectionfilter}{vtk\-Reflection\-Filter}  
\item \hyperlink{vtkgraphics_vtkregularpolygonsource}{vtk\-Regular\-Polygon\-Source}  
\item \hyperlink{vtkgraphics_vtkreversesense}{vtk\-Reverse\-Sense}  
\item \hyperlink{vtkgraphics_vtkribbonfilter}{vtk\-Ribbon\-Filter}  
\item \hyperlink{vtkgraphics_vtkrotationalextrusionfilter}{vtk\-Rotational\-Extrusion\-Filter}  
\item \hyperlink{vtkgraphics_vtkrotationfilter}{vtk\-Rotation\-Filter}  
\item \hyperlink{vtkgraphics_vtkruledsurfacefilter}{vtk\-Ruled\-Surface\-Filter}  
\item \hyperlink{vtkgraphics_vtksectorsource}{vtk\-Sector\-Source}  
\item \hyperlink{vtkgraphics_vtkselectenclosedpoints}{vtk\-Select\-Enclosed\-Points}  
\item \hyperlink{vtkgraphics_vtkselectpolydata}{vtk\-Select\-Poly\-Data}  
\item \hyperlink{vtkgraphics_vtkshrinkfilter}{vtk\-Shrink\-Filter}  
\item \hyperlink{vtkgraphics_vtkshrinkpolydata}{vtk\-Shrink\-Poly\-Data}  
\item \hyperlink{vtkgraphics_vtksimpleelevationfilter}{vtk\-Simple\-Elevation\-Filter}  
\item \hyperlink{vtkgraphics_vtkslicecubes}{vtk\-Slice\-Cubes}  
\item \hyperlink{vtkgraphics_vtksmoothpolydatafilter}{vtk\-Smooth\-Poly\-Data\-Filter}  
\item \hyperlink{vtkgraphics_vtkspatialrepresentationfilter}{vtk\-Spatial\-Representation\-Filter}  
\item \hyperlink{vtkgraphics_vtkspherepuzzle}{vtk\-Sphere\-Puzzle}  
\item \hyperlink{vtkgraphics_vtkspherepuzzlearrows}{vtk\-Sphere\-Puzzle\-Arrows}  
\item \hyperlink{vtkgraphics_vtkspheresource}{vtk\-Sphere\-Source}  
\item \hyperlink{vtkgraphics_vtksplinefilter}{vtk\-Spline\-Filter}  
\item \hyperlink{vtkgraphics_vtksplitfield}{vtk\-Split\-Field}  
\item \hyperlink{vtkgraphics_vtkstreamer}{vtk\-Streamer}  
\item \hyperlink{vtkgraphics_vtkstreamingtessellator}{vtk\-Streaming\-Tessellator}  
\item \hyperlink{vtkgraphics_vtkstreamline}{vtk\-Stream\-Line}  
\item \hyperlink{vtkgraphics_vtkstreampoints}{vtk\-Stream\-Points}  
\item \hyperlink{vtkgraphics_vtkstreamtracer}{vtk\-Stream\-Tracer}  
\item \hyperlink{vtkgraphics_vtkstripper}{vtk\-Stripper}  
\item \hyperlink{vtkgraphics_vtkstructuredgridclip}{vtk\-Structured\-Grid\-Clip}  
\item \hyperlink{vtkgraphics_vtkstructuredgridgeometryfilter}{vtk\-Structured\-Grid\-Geometry\-Filter}  
\item \hyperlink{vtkgraphics_vtkstructuredgridoutlinefilter}{vtk\-Structured\-Grid\-Outline\-Filter}  
\item \hyperlink{vtkgraphics_vtkstructuredpointsgeometryfilter}{vtk\-Structured\-Points\-Geometry\-Filter}  
\item \hyperlink{vtkgraphics_vtksubdividetetra}{vtk\-Subdivide\-Tetra}  
\item \hyperlink{vtkgraphics_vtksubpixelpositionedgels}{vtk\-Sub\-Pixel\-Position\-Edgels}  
\item \hyperlink{vtkgraphics_vtksuperquadricsource}{vtk\-Superquadric\-Source}  
\item \hyperlink{vtkgraphics_vtksynchronizedtemplates2d}{vtk\-Synchronized\-Templates2\-D}  
\item \hyperlink{vtkgraphics_vtksynchronizedtemplates3d}{vtk\-Synchronized\-Templates3\-D}  
\item \hyperlink{vtkgraphics_vtksynchronizedtemplatescutter3d}{vtk\-Synchronized\-Templates\-Cutter3\-D}  
\item \hyperlink{vtkgraphics_vtktablebasedclipdataset}{vtk\-Table\-Based\-Clip\-Data\-Set}  
\item \hyperlink{vtkgraphics_vtktabletopolydata}{vtk\-Table\-To\-Poly\-Data}  
\item \hyperlink{vtkgraphics_vtktabletostructuredgrid}{vtk\-Table\-To\-Structured\-Grid}  
\item \hyperlink{vtkgraphics_vtktemporalpathlinefilter}{vtk\-Temporal\-Path\-Line\-Filter}  
\item \hyperlink{vtkgraphics_vtktemporalstatistics}{vtk\-Temporal\-Statistics}  
\item \hyperlink{vtkgraphics_vtktensorglyph}{vtk\-Tensor\-Glyph}  
\item \hyperlink{vtkgraphics_vtktessellatedboxsource}{vtk\-Tessellated\-Box\-Source}  
\item \hyperlink{vtkgraphics_vtktessellatorfilter}{vtk\-Tessellator\-Filter}  
\item \hyperlink{vtkgraphics_vtktextsource}{vtk\-Text\-Source}  
\item \hyperlink{vtkgraphics_vtktexturedspheresource}{vtk\-Textured\-Sphere\-Source}  
\item \hyperlink{vtkgraphics_vtktexturemaptocylinder}{vtk\-Texture\-Map\-To\-Cylinder}  
\item \hyperlink{vtkgraphics_vtktexturemaptoplane}{vtk\-Texture\-Map\-To\-Plane}  
\item \hyperlink{vtkgraphics_vtktexturemaptosphere}{vtk\-Texture\-Map\-To\-Sphere}  
\item \hyperlink{vtkgraphics_vtkthreshold}{vtk\-Threshold}  
\item \hyperlink{vtkgraphics_vtkthresholdpoints}{vtk\-Threshold\-Points}  
\item \hyperlink{vtkgraphics_vtkthresholdtexturecoords}{vtk\-Threshold\-Texture\-Coords}  
\item \hyperlink{vtkgraphics_vtktimesourceexample}{vtk\-Time\-Source\-Example}  
\item \hyperlink{vtkgraphics_vtktransformcoordinatesystems}{vtk\-Transform\-Coordinate\-Systems}  
\item \hyperlink{vtkgraphics_vtktransformfilter}{vtk\-Transform\-Filter}  
\item \hyperlink{vtkgraphics_vtktransformpolydatafilter}{vtk\-Transform\-Poly\-Data\-Filter}  
\item \hyperlink{vtkgraphics_vtktransformtexturecoords}{vtk\-Transform\-Texture\-Coords}  
\item \hyperlink{vtkgraphics_vtktrianglefilter}{vtk\-Triangle\-Filter}  
\item \hyperlink{vtkgraphics_vtktriangulartcoords}{vtk\-Triangular\-T\-Coords}  
\item \hyperlink{vtkgraphics_vtktubefilter}{vtk\-Tube\-Filter}  
\item \hyperlink{vtkgraphics_vtkuncertaintytubefilter}{vtk\-Uncertainty\-Tube\-Filter}  
\item \hyperlink{vtkgraphics_vtkunstructuredgridgeometryfilter}{vtk\-Unstructured\-Grid\-Geometry\-Filter}  
\item \hyperlink{vtkgraphics_vtkvectordot}{vtk\-Vector\-Dot}  
\item \hyperlink{vtkgraphics_vtkvectornorm}{vtk\-Vector\-Norm}  
\item \hyperlink{vtkgraphics_vtkvertexglyphfilter}{vtk\-Vertex\-Glyph\-Filter}  
\item \hyperlink{vtkgraphics_vtkvoxelcontourstosurfacefilter}{vtk\-Voxel\-Contours\-To\-Surface\-Filter}  
\item \hyperlink{vtkgraphics_vtkwarplens}{vtk\-Warp\-Lens}  
\item \hyperlink{vtkgraphics_vtkwarpscalar}{vtk\-Warp\-Scalar}  
\item \hyperlink{vtkgraphics_vtkwarpto}{vtk\-Warp\-To}  
\item \hyperlink{vtkgraphics_vtkwarpvector}{vtk\-Warp\-Vector}  
\item \hyperlink{vtkgraphics_vtkwindowedsincpolydatafilter}{vtk\-Windowed\-Sinc\-Poly\-Data\-Filter}  
\item \hyperlink{vtkgraphics_vtkyoungsmaterialinterface}{vtk\-Youngs\-Material\-Interface}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkannotationlink}{}\section{vtk\-Annotation\-Link}\label{vtkgraphics_vtkannotationlink}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Annotation\-Link is a simple source filter which outputs the vtk\-Annotation\-Layers object stored internally. Multiple objects may share the same annotation link filter and connect it to an internal pipeline so that if one object changes the annotation set, it will be pulled into all the other objects when their pipelines update.

The shared vtk\-Annotation\-Layers object (a collection of annotations) is shallow copied to output port 0.

vtk\-Annotation\-Link can also store a set of domain maps. A domain map is simply a table associating values between domains. The domain of each column is defined by the array name of the column. The domain maps are sent to a multi-\/block dataset in output port 1.

Output ports 0 and 1 can be set as input ports 0 and 1 to vtk\-Convert\-Selection\-Domain, which can use the domain maps to convert the domains of selections in the vtk\-Annotation\-Layers to match a particular data object (set as port 2 on vtk\-Convert\-Selection\-Domain).

The shared vtk\-Annotation\-Layers object also stores a \char`\"{}current selection\char`\"{} normally interpreted as the interactive selection of an application. As a convenience, this selection is sent to output port 2 so that it can be connected to pipelines requiring a vtk\-Selection.

To create an instance of class vtk\-Annotation\-Link, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAnnotationLink
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Annotation\-Link has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Annotation\-Link class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Annotation\-Link = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Annotation\-Link = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Annotation\-Layers = obj.\-Get\-Annotation\-Layers ()} -\/ The annotations to be shared.  
\item {\ttfamily obj.\-Set\-Annotation\-Layers (vtk\-Annotation\-Layers layers)} -\/ The annotations to be shared.  
\item {\ttfamily obj.\-Set\-Current\-Selection (vtk\-Selection sel)} -\/ Set or get the current selection in the annotation layers.  
\item {\ttfamily vtk\-Selection = obj.\-Get\-Current\-Selection ()} -\/ Set or get the current selection in the annotation layers.  
\item {\ttfamily obj.\-Add\-Domain\-Map (vtk\-Table map)} -\/ The domain mappings.  
\item {\ttfamily obj.\-Remove\-Domain\-Map (vtk\-Table map)} -\/ The domain mappings.  
\item {\ttfamily obj.\-Remove\-All\-Domain\-Maps ()} -\/ The domain mappings.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Domain\-Maps ()} -\/ The domain mappings.  
\item {\ttfamily vtk\-Table = obj.\-Get\-Domain\-Map (int i)} -\/ The domain mappings.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Get the mtime of this object.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkappendcompositedataleaves}{}\section{vtk\-Append\-Composite\-Data\-Leaves}\label{vtkgraphics_vtkappendcompositedataleaves}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Append\-Composite\-Data\-Leaves is a filter that takes input composite datasets with the same structure\-: (1) the same number of entries and -- if any children are composites -- the same constraint holds from them; and (2) the same type of dataset at each position. It then creates an output dataset with the same structure whose leaves contain all the cells from the datasets at the corresponding leaves of the input datasets.

Currently, only input polydata and unstructured grids are handled; other types of leaf datasets will be ignored and their positions in the output dataset will be N\-U\-L\-L pointers. Point attributes (i.\-e., scalars, vectors, normals, field data, etc.) are extracted and appended only if all datasets have the point attributes available. (For example, if one dataset has scalars but another does not, scalars will not be appended.)

To create an instance of class vtk\-Append\-Composite\-Data\-Leaves, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAppendCompositeDataLeaves
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Append\-Composite\-Data\-Leaves has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Append\-Composite\-Data\-Leaves class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Append\-Composite\-Data\-Leaves = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Append\-Composite\-Data\-Leaves = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Remove\-Input (vtk\-Data\-Set in)} -\/ Remove a dataset from the list of data to append.  
\item {\ttfamily obj.\-Set\-Append\-Field\-Data (int )} -\/ Set/get whether the field data of each dataset in the composite dataset is copied to the output. If Append\-Field\-Data is non-\/zero, then field data arrays from all the inputs are added to the output. If there are duplicates, the array on the first input encountered is taken.  
\item {\ttfamily int = obj.\-Get\-Append\-Field\-Data ()} -\/ Set/get whether the field data of each dataset in the composite dataset is copied to the output. If Append\-Field\-Data is non-\/zero, then field data arrays from all the inputs are added to the output. If there are duplicates, the array on the first input encountered is taken.  
\item {\ttfamily obj.\-Append\-Field\-Data\-On ()} -\/ Set/get whether the field data of each dataset in the composite dataset is copied to the output. If Append\-Field\-Data is non-\/zero, then field data arrays from all the inputs are added to the output. If there are duplicates, the array on the first input encountered is taken.  
\item {\ttfamily obj.\-Append\-Field\-Data\-Off ()} -\/ Set/get whether the field data of each dataset in the composite dataset is copied to the output. If Append\-Field\-Data is non-\/zero, then field data arrays from all the inputs are added to the output. If there are duplicates, the array on the first input encountered is taken.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkappendfilter}{}\section{vtk\-Append\-Filter}\label{vtkgraphics_vtkappendfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Append\-Filter is a filter that appends one of more datasets into a single unstructured grid. All geometry is extracted and appended, but point attributes (i.\-e., scalars, vectors, normals, field data, etc.) are extracted and appended only if all datasets have the point attributes available. (For example, if one dataset has scalars but another does not, scalars will not be appended.)

To create an instance of class vtk\-Append\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAppendFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Append\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Append\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Append\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Append\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Remove\-Input (vtk\-Data\-Set in)} -\/ Remove a dataset from the list of data to append.  
\item {\ttfamily vtk\-Data\-Set\-Collection = obj.\-Get\-Input\-List ()} -\/ Returns a copy of the input array. Modifications to this list will not be reflected in the actual inputs.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkappendpolydata}{}\section{vtk\-Append\-Poly\-Data}\label{vtkgraphics_vtkappendpolydata}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Append\-Poly\-Data is a filter that appends one of more polygonal datasets into a single polygonal dataset. All geometry is extracted and appended, but point and cell attributes (i.\-e., scalars, vectors, normals) are extracted and appended only if all datasets have the point and/or cell attributes available. (For example, if one dataset has point scalars but another does not, point scalars will not be appended.)

To create an instance of class vtk\-Append\-Poly\-Data, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAppendPolyData
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Append\-Poly\-Data has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Append\-Poly\-Data class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Append\-Poly\-Data = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Append\-Poly\-Data = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-User\-Managed\-Inputs (int )} -\/ User\-Managed\-Inputs allows the user to set inputs by number instead of using the Add\-Input/\-Remove\-Input functions. Calls to Set\-Number\-Of\-Inputs/\-Set\-Input\-By\-Number should not be mixed with calls to Add\-Input/\-Remove\-Input. By default, User\-Managed\-Inputs is false.  
\item {\ttfamily int = obj.\-Get\-User\-Managed\-Inputs ()} -\/ User\-Managed\-Inputs allows the user to set inputs by number instead of using the Add\-Input/\-Remove\-Input functions. Calls to Set\-Number\-Of\-Inputs/\-Set\-Input\-By\-Number should not be mixed with calls to Add\-Input/\-Remove\-Input. By default, User\-Managed\-Inputs is false.  
\item {\ttfamily obj.\-User\-Managed\-Inputs\-On ()} -\/ User\-Managed\-Inputs allows the user to set inputs by number instead of using the Add\-Input/\-Remove\-Input functions. Calls to Set\-Number\-Of\-Inputs/\-Set\-Input\-By\-Number should not be mixed with calls to Add\-Input/\-Remove\-Input. By default, User\-Managed\-Inputs is false.  
\item {\ttfamily obj.\-User\-Managed\-Inputs\-Off ()} -\/ User\-Managed\-Inputs allows the user to set inputs by number instead of using the Add\-Input/\-Remove\-Input functions. Calls to Set\-Number\-Of\-Inputs/\-Set\-Input\-By\-Number should not be mixed with calls to Add\-Input/\-Remove\-Input. By default, User\-Managed\-Inputs is false.  
\item {\ttfamily obj.\-Add\-Input (vtk\-Poly\-Data )} -\/ Add a dataset to the list of data to append. Should not be used when User\-Managed\-Inputs is true, use Set\-Input\-By\-Number instead.  
\item {\ttfamily obj.\-Remove\-Input (vtk\-Poly\-Data )} -\/ Remove a dataset from the list of data to append. Should not be used when User\-Managed\-Inputs is true, use Set\-Input\-By\-Number (N\-U\-L\-L) instead.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Inputs (int num)} -\/ Directly set(allocate) number of inputs, should only be used when User\-Managed\-Inputs is true.  
\item {\ttfamily obj.\-Set\-Input\-By\-Number (int num, vtk\-Poly\-Data input)}  
\item {\ttfamily obj.\-Set\-Parallel\-Streaming (int )} -\/ Parallel\-Streaming is for a particular application. It causes this filter to ask for a different piece from each of its inputs. If all the inputs are the same, then the output of this append filter is the whole dataset pieced back together. Duplicate points are create along the seams. The purpose of this feature is to get data parallelism at a course scale. Each of the inputs can be generated in a different process at the same time.  
\item {\ttfamily int = obj.\-Get\-Parallel\-Streaming ()} -\/ Parallel\-Streaming is for a particular application. It causes this filter to ask for a different piece from each of its inputs. If all the inputs are the same, then the output of this append filter is the whole dataset pieced back together. Duplicate points are create along the seams. The purpose of this feature is to get data parallelism at a course scale. Each of the inputs can be generated in a different process at the same time.  
\item {\ttfamily obj.\-Parallel\-Streaming\-On ()} -\/ Parallel\-Streaming is for a particular application. It causes this filter to ask for a different piece from each of its inputs. If all the inputs are the same, then the output of this append filter is the whole dataset pieced back together. Duplicate points are create along the seams. The purpose of this feature is to get data parallelism at a course scale. Each of the inputs can be generated in a different process at the same time.  
\item {\ttfamily obj.\-Parallel\-Streaming\-Off ()} -\/ Parallel\-Streaming is for a particular application. It causes this filter to ask for a different piece from each of its inputs. If all the inputs are the same, then the output of this append filter is the whole dataset pieced back together. Duplicate points are create along the seams. The purpose of this feature is to get data parallelism at a course scale. Each of the inputs can be generated in a different process at the same time.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkappendselection}{}\section{vtk\-Append\-Selection}\label{vtkgraphics_vtkappendselection}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Append\-Selection is a filter that appends one of more selections into a single selection. All selections must have the same content type unless Append\-By\-Union is false.

To create an instance of class vtk\-Append\-Selection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAppendSelection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Append\-Selection has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Append\-Selection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Append\-Selection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Append\-Selection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-User\-Managed\-Inputs (int )} -\/ User\-Managed\-Inputs allows the user to set inputs by number instead of using the Add\-Input/\-Remove\-Input functions. Calls to Set\-Number\-Of\-Inputs/\-Set\-Input\-By\-Number should not be mixed with calls to Add\-Input/\-Remove\-Input. By default, User\-Managed\-Inputs is false.  
\item {\ttfamily int = obj.\-Get\-User\-Managed\-Inputs ()} -\/ User\-Managed\-Inputs allows the user to set inputs by number instead of using the Add\-Input/\-Remove\-Input functions. Calls to Set\-Number\-Of\-Inputs/\-Set\-Input\-By\-Number should not be mixed with calls to Add\-Input/\-Remove\-Input. By default, User\-Managed\-Inputs is false.  
\item {\ttfamily obj.\-User\-Managed\-Inputs\-On ()} -\/ User\-Managed\-Inputs allows the user to set inputs by number instead of using the Add\-Input/\-Remove\-Input functions. Calls to Set\-Number\-Of\-Inputs/\-Set\-Input\-By\-Number should not be mixed with calls to Add\-Input/\-Remove\-Input. By default, User\-Managed\-Inputs is false.  
\item {\ttfamily obj.\-User\-Managed\-Inputs\-Off ()} -\/ User\-Managed\-Inputs allows the user to set inputs by number instead of using the Add\-Input/\-Remove\-Input functions. Calls to Set\-Number\-Of\-Inputs/\-Set\-Input\-By\-Number should not be mixed with calls to Add\-Input/\-Remove\-Input. By default, User\-Managed\-Inputs is false.  
\item {\ttfamily obj.\-Add\-Input (vtk\-Selection )} -\/ Add a dataset to the list of data to append. Should not be used when User\-Managed\-Inputs is true, use Set\-Input\-By\-Number instead.  
\item {\ttfamily obj.\-Remove\-Input (vtk\-Selection )} -\/ Remove a dataset from the list of data to append. Should not be used when User\-Managed\-Inputs is true, use Set\-Input\-By\-Number (N\-U\-L\-L) instead.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Inputs (int num)} -\/ Directly set(allocate) number of inputs, should only be used when User\-Managed\-Inputs is true.  
\item {\ttfamily obj.\-Set\-Input\-By\-Number (int num, vtk\-Selection input)}  
\item {\ttfamily obj.\-Set\-Append\-By\-Union (int )} -\/ When set to true, all the selections are combined together to form a single vtk\-Selection output. When set to false, the output is a composite selection with input selections as the children of the composite selection. This allows for selections with different content types and properties. Default is true.  
\item {\ttfamily int = obj.\-Get\-Append\-By\-Union ()} -\/ When set to true, all the selections are combined together to form a single vtk\-Selection output. When set to false, the output is a composite selection with input selections as the children of the composite selection. This allows for selections with different content types and properties. Default is true.  
\item {\ttfamily obj.\-Append\-By\-Union\-On ()} -\/ When set to true, all the selections are combined together to form a single vtk\-Selection output. When set to false, the output is a composite selection with input selections as the children of the composite selection. This allows for selections with different content types and properties. Default is true.  
\item {\ttfamily obj.\-Append\-By\-Union\-Off ()} -\/ When set to true, all the selections are combined together to form a single vtk\-Selection output. When set to false, the output is a composite selection with input selections as the children of the composite selection. This allows for selections with different content types and properties. Default is true.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkapproximatingsubdivisionfilter}{}\section{vtk\-Approximating\-Subdivision\-Filter}\label{vtkgraphics_vtkapproximatingsubdivisionfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Approximating\-Subdivision\-Filter is an abstract class that defines the protocol for Approximating subdivision surface filters.

To create an instance of class vtk\-Approximating\-Subdivision\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkApproximatingSubdivisionFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Approximating\-Subdivision\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Approximating\-Subdivision\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Approximating\-Subdivision\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Approximating\-Subdivision\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Number\-Of\-Subdivisions (int )} -\/ Set/get the number of subdivisions.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Subdivisions ()} -\/ Set/get the number of subdivisions.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkarcsource}{}\section{vtk\-Arc\-Source}\label{vtkgraphics_vtkarcsource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Arc\-Source is a source object that creates an arc defined by two endpoints and a center. The number of segments composing the polyline is controlled by setting the object resolution.

To create an instance of class vtk\-Arc\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkArcSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Arc\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Arc\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Arc\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Arc\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Point1 (double , double , double )} -\/ Set position of first end point.  
\item {\ttfamily obj.\-Set\-Point1 (double a\mbox{[}3\mbox{]})} -\/ Set position of first end point.  
\item {\ttfamily double = obj. Get\-Point1 ()} -\/ Set position of first end point.  
\item {\ttfamily obj.\-Set\-Point2 (double , double , double )} -\/ Set position of other end point.  
\item {\ttfamily obj.\-Set\-Point2 (double a\mbox{[}3\mbox{]})} -\/ Set position of other end point.  
\item {\ttfamily double = obj. Get\-Point2 ()} -\/ Set position of other end point.  
\item {\ttfamily obj.\-Set\-Center (double , double , double )} -\/ Set position of the center of the circle that define the arc. Note\-: you can use the function vtk\-Math\-::\-Solve3\-Point\-Circle to find the center from 3 points located on a circle.  
\item {\ttfamily obj.\-Set\-Center (double a\mbox{[}3\mbox{]})} -\/ Set position of the center of the circle that define the arc. Note\-: you can use the function vtk\-Math\-::\-Solve3\-Point\-Circle to find the center from 3 points located on a circle.  
\item {\ttfamily double = obj. Get\-Center ()} -\/ Set position of the center of the circle that define the arc. Note\-: you can use the function vtk\-Math\-::\-Solve3\-Point\-Circle to find the center from 3 points located on a circle.  
\item {\ttfamily obj.\-Set\-Resolution (int )} -\/ Divide line into resolution number of pieces. Note\-: if Resolution is set to 1 (default), the arc is a straight line.  
\item {\ttfamily int = obj.\-Get\-Resolution\-Min\-Value ()} -\/ Divide line into resolution number of pieces. Note\-: if Resolution is set to 1 (default), the arc is a straight line.  
\item {\ttfamily int = obj.\-Get\-Resolution\-Max\-Value ()} -\/ Divide line into resolution number of pieces. Note\-: if Resolution is set to 1 (default), the arc is a straight line.  
\item {\ttfamily int = obj.\-Get\-Resolution ()} -\/ Divide line into resolution number of pieces. Note\-: if Resolution is set to 1 (default), the arc is a straight line.  
\item {\ttfamily obj.\-Set\-Negative (bool )} -\/ Use the angle that is a negative coterminal of the vectors angle\-: the longest angle. Note\-: false by default.  
\item {\ttfamily bool = obj.\-Get\-Negative ()} -\/ Use the angle that is a negative coterminal of the vectors angle\-: the longest angle. Note\-: false by default.  
\item {\ttfamily obj.\-Negative\-On ()} -\/ Use the angle that is a negative coterminal of the vectors angle\-: the longest angle. Note\-: false by default.  
\item {\ttfamily obj.\-Negative\-Off ()} -\/ Use the angle that is a negative coterminal of the vectors angle\-: the longest angle. Note\-: false by default.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkarraycalculator}{}\section{vtk\-Array\-Calculator}\label{vtkgraphics_vtkarraycalculator}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Array\-Calculator performs operations on vectors or scalars in field data arrays. It uses vtk\-Function\-Parser to do the parsing and to evaluate the function for each entry in the input arrays. The arrays used in a given function must be all in point data or all in cell data. The resulting array will be stored as a field data array. The result array can either be stored in a new array or it can overwrite an existing array.

The functions that this array calculator understands is\-: 
\begin{DoxyPre}
 standard operations: + - * / ^ .
 build unit vectors: iHat, jHat, kHat (ie (1,0,0), (0,1,0), (0,0,1))
 abs
 acos
 asin
 atan
 ceil
 cos
 cosh
 exp
 floor
 log
 mag
 min
 max
 norm
 sign
 sin
 sinh
 sqrt
 tan
 tanh
 \end{DoxyPre}
 Note that some of these operations work on scalars, some on vectors, and some on both (e.\-g., you can multiply a scalar times a vector). The operations are performed tuple-\/wise (i.\-e., tuple-\/by-\/tuple). The user must specify which arrays to use as vectors and/or scalars, and the name of the output data array.

To create an instance of class vtk\-Array\-Calculator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkArrayCalculator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Array\-Calculator has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Calculator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Array\-Calculator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Array\-Calculator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Function (string function)} -\/ Set/\-Get the function to be evaluated.  
\item {\ttfamily string = obj.\-Get\-Function ()} -\/ Set/\-Get the function to be evaluated.  
\item {\ttfamily obj.\-Add\-Scalar\-Array\-Name (string array\-Name, int component)} -\/ Add an array name to the list of arrays used in the function and specify which components of the array to use in evaluating the function. The array name must match the name in the function. Use Add\-Scalar\-Variable or Add\-Vector\-Variable to use a variable name different from the array name.  
\item {\ttfamily obj.\-Add\-Vector\-Array\-Name (string array\-Name, int component0, int component1, int component2)} -\/ Add an array name to the list of arrays used in the function and specify which components of the array to use in evaluating the function. The array name must match the name in the function. Use Add\-Scalar\-Variable or Add\-Vector\-Variable to use a variable name different from the array name.  
\item {\ttfamily obj.\-Add\-Scalar\-Variable (string variable\-Name, string array\-Name, int component)} -\/ Add a variable name, a corresponding array name, and which components of the array to use.  
\item {\ttfamily obj.\-Add\-Vector\-Variable (string variable\-Name, string array\-Name, int component0, int component1, int component2)} -\/ Add a variable name, a corresponding array name, and which components of the array to use.  
\item {\ttfamily obj.\-Add\-Coordinate\-Scalar\-Variable (string variable\-Name, int component)} -\/ Add a variable name, a corresponding array name, and which components of the array to use.  
\item {\ttfamily obj.\-Add\-Coordinate\-Vector\-Variable (string variable\-Name, int component0, int component1, int component2)} -\/ Add a variable name, a corresponding array name, and which components of the array to use.  
\item {\ttfamily obj.\-Set\-Result\-Array\-Name (string name)} -\/ Set the name of the array in which to store the result of evaluating this function. If this is the name of an existing array, that array will be overwritten. Otherwise a new array will be created with the specified name.  
\item {\ttfamily string = obj.\-Get\-Result\-Array\-Name ()} -\/ Set the name of the array in which to store the result of evaluating this function. If this is the name of an existing array, that array will be overwritten. Otherwise a new array will be created with the specified name.  
\item {\ttfamily int = obj.\-Get\-Result\-Array\-Type ()} -\/ Type of the result array. It is ignored if Coordinate\-Results is true. Initial value is V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E.  
\item {\ttfamily obj.\-Set\-Result\-Array\-Type (int )} -\/ Type of the result array. It is ignored if Coordinate\-Results is true. Initial value is V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E.  
\item {\ttfamily int = obj.\-Get\-Coordinate\-Results ()} -\/ Set whether to output results as coordinates. Result\-Array\-Name will be ignored. Outputing as coordinates is only valid with vector results and if the Attribute\-Mode is Attribute\-Mode\-To\-Use\-Point\-Data. If a valid output can't be made, an error will occur.  
\item {\ttfamily obj.\-Set\-Coordinate\-Results (int )} -\/ Set whether to output results as coordinates. Result\-Array\-Name will be ignored. Outputing as coordinates is only valid with vector results and if the Attribute\-Mode is Attribute\-Mode\-To\-Use\-Point\-Data. If a valid output can't be made, an error will occur.  
\item {\ttfamily obj.\-Coordinate\-Results\-On ()} -\/ Set whether to output results as coordinates. Result\-Array\-Name will be ignored. Outputing as coordinates is only valid with vector results and if the Attribute\-Mode is Attribute\-Mode\-To\-Use\-Point\-Data. If a valid output can't be made, an error will occur.  
\item {\ttfamily obj.\-Coordinate\-Results\-Off ()} -\/ Set whether to output results as coordinates. Result\-Array\-Name will be ignored. Outputing as coordinates is only valid with vector results and if the Attribute\-Mode is Attribute\-Mode\-To\-Use\-Point\-Data. If a valid output can't be made, an error will occur.  
\item {\ttfamily obj.\-Set\-Attribute\-Mode (int )} -\/ Control whether the filter operates on point data or cell data. By default (Attribute\-Mode\-To\-Default), the filter uses point data. Alternatively you can explicitly set the filter to use point data (Attribute\-Mode\-To\-Use\-Point\-Data) or cell data (Attribute\-Mode\-To\-Use\-Cell\-Data). For graphs you can set the filter to use vertex data (Attribute\-Mode\-To\-Use\-Vertex\-Data) or edge data (Attribute\-Mode\-To\-Use\-Edge\-Data).  
\item {\ttfamily int = obj.\-Get\-Attribute\-Mode ()} -\/ Control whether the filter operates on point data or cell data. By default (Attribute\-Mode\-To\-Default), the filter uses point data. Alternatively you can explicitly set the filter to use point data (Attribute\-Mode\-To\-Use\-Point\-Data) or cell data (Attribute\-Mode\-To\-Use\-Cell\-Data). For graphs you can set the filter to use vertex data (Attribute\-Mode\-To\-Use\-Vertex\-Data) or edge data (Attribute\-Mode\-To\-Use\-Edge\-Data).  
\item {\ttfamily obj.\-Set\-Attribute\-Mode\-To\-Default ()} -\/ Control whether the filter operates on point data or cell data. By default (Attribute\-Mode\-To\-Default), the filter uses point data. Alternatively you can explicitly set the filter to use point data (Attribute\-Mode\-To\-Use\-Point\-Data) or cell data (Attribute\-Mode\-To\-Use\-Cell\-Data). For graphs you can set the filter to use vertex data (Attribute\-Mode\-To\-Use\-Vertex\-Data) or edge data (Attribute\-Mode\-To\-Use\-Edge\-Data).  
\item {\ttfamily obj.\-Set\-Attribute\-Mode\-To\-Use\-Point\-Data ()} -\/ Control whether the filter operates on point data or cell data. By default (Attribute\-Mode\-To\-Default), the filter uses point data. Alternatively you can explicitly set the filter to use point data (Attribute\-Mode\-To\-Use\-Point\-Data) or cell data (Attribute\-Mode\-To\-Use\-Cell\-Data). For graphs you can set the filter to use vertex data (Attribute\-Mode\-To\-Use\-Vertex\-Data) or edge data (Attribute\-Mode\-To\-Use\-Edge\-Data).  
\item {\ttfamily obj.\-Set\-Attribute\-Mode\-To\-Use\-Cell\-Data ()} -\/ Control whether the filter operates on point data or cell data. By default (Attribute\-Mode\-To\-Default), the filter uses point data. Alternatively you can explicitly set the filter to use point data (Attribute\-Mode\-To\-Use\-Point\-Data) or cell data (Attribute\-Mode\-To\-Use\-Cell\-Data). For graphs you can set the filter to use vertex data (Attribute\-Mode\-To\-Use\-Vertex\-Data) or edge data (Attribute\-Mode\-To\-Use\-Edge\-Data).  
\item {\ttfamily obj.\-Set\-Attribute\-Mode\-To\-Use\-Vertex\-Data ()} -\/ Control whether the filter operates on point data or cell data. By default (Attribute\-Mode\-To\-Default), the filter uses point data. Alternatively you can explicitly set the filter to use point data (Attribute\-Mode\-To\-Use\-Point\-Data) or cell data (Attribute\-Mode\-To\-Use\-Cell\-Data). For graphs you can set the filter to use vertex data (Attribute\-Mode\-To\-Use\-Vertex\-Data) or edge data (Attribute\-Mode\-To\-Use\-Edge\-Data).  
\item {\ttfamily obj.\-Set\-Attribute\-Mode\-To\-Use\-Edge\-Data ()} -\/ Control whether the filter operates on point data or cell data. By default (Attribute\-Mode\-To\-Default), the filter uses point data. Alternatively you can explicitly set the filter to use point data (Attribute\-Mode\-To\-Use\-Point\-Data) or cell data (Attribute\-Mode\-To\-Use\-Cell\-Data). For graphs you can set the filter to use vertex data (Attribute\-Mode\-To\-Use\-Vertex\-Data) or edge data (Attribute\-Mode\-To\-Use\-Edge\-Data).  
\item {\ttfamily string = obj.\-Get\-Attribute\-Mode\-As\-String ()} -\/ Control whether the filter operates on point data or cell data. By default (Attribute\-Mode\-To\-Default), the filter uses point data. Alternatively you can explicitly set the filter to use point data (Attribute\-Mode\-To\-Use\-Point\-Data) or cell data (Attribute\-Mode\-To\-Use\-Cell\-Data). For graphs you can set the filter to use vertex data (Attribute\-Mode\-To\-Use\-Vertex\-Data) or edge data (Attribute\-Mode\-To\-Use\-Edge\-Data).  
\item {\ttfamily obj.\-Remove\-All\-Variables ()} -\/ Remove all the variable names and their associated array names.  
\item {\ttfamily obj.\-Remove\-Scalar\-Variables ()} -\/ Remove all the scalar variable names and their associated array names.  
\item {\ttfamily obj.\-Remove\-Vector\-Variables ()} -\/ Remove all the scalar variable names and their associated array names.  
\item {\ttfamily obj.\-Remove\-Coordinate\-Scalar\-Variables ()} -\/ Remove all the coordinate variables.  
\item {\ttfamily obj.\-Remove\-Coordinate\-Vector\-Variables ()} -\/ Remove all the coordinate variables.  
\item {\ttfamily string = obj.\-Get\-Scalar\-Array\-Name (int i)} -\/ Methods to get information about the current variables.  
\item {\ttfamily string = obj.\-Get\-Vector\-Array\-Name (int i)} -\/ Methods to get information about the current variables.  
\item {\ttfamily string = obj.\-Get\-Scalar\-Variable\-Name (int i)} -\/ Methods to get information about the current variables.  
\item {\ttfamily string = obj.\-Get\-Vector\-Variable\-Name (int i)} -\/ Methods to get information about the current variables.  
\item {\ttfamily int = obj.\-Get\-Selected\-Scalar\-Component (int i)} -\/ Methods to get information about the current variables.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Scalar\-Arrays ()} -\/ Methods to get information about the current variables.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Vector\-Arrays ()} -\/ Methods to get information about the current variables.  
\item {\ttfamily obj.\-Set\-Replace\-Invalid\-Values (int )} -\/ When Replace\-Invalid\-Values is on, all invalid values (such as sqrt(-\/2), note that function parser does not handle complex numbers) will be replaced by Replacement\-Value. Otherwise an error will be reported  
\item {\ttfamily int = obj.\-Get\-Replace\-Invalid\-Values ()} -\/ When Replace\-Invalid\-Values is on, all invalid values (such as sqrt(-\/2), note that function parser does not handle complex numbers) will be replaced by Replacement\-Value. Otherwise an error will be reported  
\item {\ttfamily obj.\-Replace\-Invalid\-Values\-On ()} -\/ When Replace\-Invalid\-Values is on, all invalid values (such as sqrt(-\/2), note that function parser does not handle complex numbers) will be replaced by Replacement\-Value. Otherwise an error will be reported  
\item {\ttfamily obj.\-Replace\-Invalid\-Values\-Off ()} -\/ When Replace\-Invalid\-Values is on, all invalid values (such as sqrt(-\/2), note that function parser does not handle complex numbers) will be replaced by Replacement\-Value. Otherwise an error will be reported  
\item {\ttfamily obj.\-Set\-Replacement\-Value (double )} -\/ When Replace\-Invalid\-Values is on, all invalid values (such as sqrt(-\/2), note that function parser does not handle complex numbers) will be replaced by Replacement\-Value. Otherwise an error will be reported  
\item {\ttfamily double = obj.\-Get\-Replacement\-Value ()} -\/ When Replace\-Invalid\-Values is on, all invalid values (such as sqrt(-\/2), note that function parser does not handle complex numbers) will be replaced by Replacement\-Value. Otherwise an error will be reported  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkarrowsource}{}\section{vtk\-Arrow\-Source}\label{vtkgraphics_vtkarrowsource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Arrow\-Source was intended to be used as the source for a glyph. The shaft base is always at (0,0,0). The arrow tip is always at (1,0,0). If \char`\"{}\-Invert\char`\"{} is true, then the ends are flipped i.\-e. tip is at (0,0,0) while base is at (1, 0, 0). The resolution of the cone and shaft can be set and default to 6. The radius of the cone and shaft can be set and default to 0.\-03 and 0.\-1. The length of the tip can also be set, and defaults to 0.\-35.

To create an instance of class vtk\-Arrow\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkArrowSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Arrow\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Arrow\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Arrow\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Arrow\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Tip\-Length (double )} -\/ Set the length, and radius of the tip. They default to 0.\-35 and 0.\-1  
\item {\ttfamily double = obj.\-Get\-Tip\-Length\-Min\-Value ()} -\/ Set the length, and radius of the tip. They default to 0.\-35 and 0.\-1  
\item {\ttfamily double = obj.\-Get\-Tip\-Length\-Max\-Value ()} -\/ Set the length, and radius of the tip. They default to 0.\-35 and 0.\-1  
\item {\ttfamily double = obj.\-Get\-Tip\-Length ()} -\/ Set the length, and radius of the tip. They default to 0.\-35 and 0.\-1  
\item {\ttfamily obj.\-Set\-Tip\-Radius (double )} -\/ Set the length, and radius of the tip. They default to 0.\-35 and 0.\-1  
\item {\ttfamily double = obj.\-Get\-Tip\-Radius\-Min\-Value ()} -\/ Set the length, and radius of the tip. They default to 0.\-35 and 0.\-1  
\item {\ttfamily double = obj.\-Get\-Tip\-Radius\-Max\-Value ()} -\/ Set the length, and radius of the tip. They default to 0.\-35 and 0.\-1  
\item {\ttfamily double = obj.\-Get\-Tip\-Radius ()} -\/ Set the length, and radius of the tip. They default to 0.\-35 and 0.\-1  
\item {\ttfamily obj.\-Set\-Tip\-Resolution (int )} -\/ Set the resolution of the tip. The tip behaves the same as a cone. Resoultion 1 gives a single triangle, 2 gives two crossed triangles.  
\item {\ttfamily int = obj.\-Get\-Tip\-Resolution\-Min\-Value ()} -\/ Set the resolution of the tip. The tip behaves the same as a cone. Resoultion 1 gives a single triangle, 2 gives two crossed triangles.  
\item {\ttfamily int = obj.\-Get\-Tip\-Resolution\-Max\-Value ()} -\/ Set the resolution of the tip. The tip behaves the same as a cone. Resoultion 1 gives a single triangle, 2 gives two crossed triangles.  
\item {\ttfamily int = obj.\-Get\-Tip\-Resolution ()} -\/ Set the resolution of the tip. The tip behaves the same as a cone. Resoultion 1 gives a single triangle, 2 gives two crossed triangles.  
\item {\ttfamily obj.\-Set\-Shaft\-Radius (double )} -\/ Set the radius of the shaft. Defaults to 0.\-03.  
\item {\ttfamily double = obj.\-Get\-Shaft\-Radius\-Min\-Value ()} -\/ Set the radius of the shaft. Defaults to 0.\-03.  
\item {\ttfamily double = obj.\-Get\-Shaft\-Radius\-Max\-Value ()} -\/ Set the radius of the shaft. Defaults to 0.\-03.  
\item {\ttfamily double = obj.\-Get\-Shaft\-Radius ()} -\/ Set the radius of the shaft. Defaults to 0.\-03.  
\item {\ttfamily obj.\-Set\-Shaft\-Resolution (int )} -\/ Set the resolution of the shaft. 2 gives a rectangle. I would like to extend the cone to produce a line, but this is not an option now.  
\item {\ttfamily int = obj.\-Get\-Shaft\-Resolution\-Min\-Value ()} -\/ Set the resolution of the shaft. 2 gives a rectangle. I would like to extend the cone to produce a line, but this is not an option now.  
\item {\ttfamily int = obj.\-Get\-Shaft\-Resolution\-Max\-Value ()} -\/ Set the resolution of the shaft. 2 gives a rectangle. I would like to extend the cone to produce a line, but this is not an option now.  
\item {\ttfamily int = obj.\-Get\-Shaft\-Resolution ()} -\/ Set the resolution of the shaft. 2 gives a rectangle. I would like to extend the cone to produce a line, but this is not an option now.  
\item {\ttfamily obj.\-Invert\-On ()} -\/ Inverts the arrow direction. When set to true, base is at (1, 0, 0) while the tip is at (0, 0, 0). The default is false, i.\-e. base at (0, 0, 0) and the tip at (1, 0, 0).  
\item {\ttfamily obj.\-Invert\-Off ()} -\/ Inverts the arrow direction. When set to true, base is at (1, 0, 0) while the tip is at (0, 0, 0). The default is false, i.\-e. base at (0, 0, 0) and the tip at (1, 0, 0).  
\item {\ttfamily obj.\-Set\-Invert (bool )} -\/ Inverts the arrow direction. When set to true, base is at (1, 0, 0) while the tip is at (0, 0, 0). The default is false, i.\-e. base at (0, 0, 0) and the tip at (1, 0, 0).  
\item {\ttfamily bool = obj.\-Get\-Invert ()} -\/ Inverts the arrow direction. When set to true, base is at (1, 0, 0) while the tip is at (0, 0, 0). The default is false, i.\-e. base at (0, 0, 0) and the tip at (1, 0, 0).  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkassignattribute}{}\section{vtk\-Assign\-Attribute}\label{vtkgraphics_vtkassignattribute}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Assign\-Attribute is use to label a field (vtk\-Data\-Array) as an attribute. A field name or an attribute to labeled can be specified. For example\-: \begin{DoxyVerb} aa->Assign("foo", vtkDataSetAttributes::SCALARS, 
            vtkAssignAttribute::POINT_DATA);\end{DoxyVerb}
 tells vtk\-Assign\-Attribute to make the array in the point data called \char`\"{}foo\char`\"{} the active scalars. On the other hand, \begin{DoxyVerb} aa->Assign(vtkDataSetAttributes::VECTORS, vtkDataSetAttributes::SCALARS, 
            vtkAssignAttribute::POINT_DATA);\end{DoxyVerb}
 tells vtk\-Assign\-Attribute to make the active vectors also the active scalars. The same can be done more easily from Tcl by using the Assign() method which takes strings\-: \begin{DoxyVerb} aa Assign "foo" SCALARS POINT_DATA 
 or
 aa Assign SCALARS VECTORS POINT_DATA

 AttributeTypes: SCALARS, VECTORS, NORMALS, TCOORDS, TENSORS
 Attribute locations: POINT_DATA, CELL_DATA\end{DoxyVerb}


To create an instance of class vtk\-Assign\-Attribute, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAssignAttribute
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Assign\-Attribute has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Assign\-Attribute class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Assign\-Attribute = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Assign\-Attribute = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Assign (int input\-Attribute\-Type, int attribute\-Type, int attribute\-Loc)} -\/ Label an attribute as another attribute.  
\item {\ttfamily obj.\-Assign (string field\-Name, int attribute\-Type, int attribute\-Loc)} -\/ Label an array as an attribute.  
\item {\ttfamily obj.\-Assign (string name, string attribute\-Type, string attribute\-Loc)} -\/ Helper method used by other language bindings. Allows the caller to specify arguments as strings instead of enums.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkattributedatatofielddatafilter}{}\section{vtk\-Attribute\-Data\-To\-Field\-Data\-Filter}\label{vtkgraphics_vtkattributedatatofielddatafilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Attribute\-Data\-To\-Field\-Data\-Filter is a class that maps attribute data into field data. Since this filter is a subclass of vtk\-Data\-Set\-Algorithm, the output dataset (whose structure is the same as the input dataset), will contain the field data that is generated. The filter will convert point and cell attribute data to field data and assign it as point and cell field data, replacing any point or field data that was there previously. By default, the original non-\/field point and cell attribute data will be passed to the output of the filter, although you can shut this behavior down.

To create an instance of class vtk\-Attribute\-Data\-To\-Field\-Data\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAttributeDataToFieldDataFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Attribute\-Data\-To\-Field\-Data\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Attribute\-Data\-To\-Field\-Data\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Attribute\-Data\-To\-Field\-Data\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Attribute\-Data\-To\-Field\-Data\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Pass\-Attribute\-Data (int )} -\/ Turn on/off the passing of point and cell non-\/field attribute data to the output of the filter.  
\item {\ttfamily int = obj.\-Get\-Pass\-Attribute\-Data ()} -\/ Turn on/off the passing of point and cell non-\/field attribute data to the output of the filter.  
\item {\ttfamily obj.\-Pass\-Attribute\-Data\-On ()} -\/ Turn on/off the passing of point and cell non-\/field attribute data to the output of the filter.  
\item {\ttfamily obj.\-Pass\-Attribute\-Data\-Off ()} -\/ Turn on/off the passing of point and cell non-\/field attribute data to the output of the filter.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkaxes}{}\section{vtk\-Axes}\label{vtkgraphics_vtkaxes}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Axes creates three lines that form an x-\/y-\/z axes. The origin of the axes is user specified (0,0,0 is default), and the size is specified with a scale factor. Three scalar values are generated for the three lines and can be used (via color map) to indicate a particular coordinate axis.

To create an instance of class vtk\-Axes, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAxes
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Axes has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Axes class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Axes = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Axes = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Origin (double , double , double )} -\/ Set the origin of the axes.  
\item {\ttfamily obj.\-Set\-Origin (double a\mbox{[}3\mbox{]})} -\/ Set the origin of the axes.  
\item {\ttfamily double = obj. Get\-Origin ()} -\/ Set the origin of the axes.  
\item {\ttfamily obj.\-Set\-Scale\-Factor (double )} -\/ Set the scale factor of the axes. Used to control size.  
\item {\ttfamily double = obj.\-Get\-Scale\-Factor ()} -\/ Set the scale factor of the axes. Used to control size.  
\item {\ttfamily obj.\-Set\-Symmetric (int )} -\/ If Symetric is on, the the axis continue to negative values.  
\item {\ttfamily int = obj.\-Get\-Symmetric ()} -\/ If Symetric is on, the the axis continue to negative values.  
\item {\ttfamily obj.\-Symmetric\-On ()} -\/ If Symetric is on, the the axis continue to negative values.  
\item {\ttfamily obj.\-Symmetric\-Off ()} -\/ If Symetric is on, the the axis continue to negative values.  
\item {\ttfamily obj.\-Set\-Compute\-Normals (int )} -\/ Option for computing normals. By default they are computed.  
\item {\ttfamily int = obj.\-Get\-Compute\-Normals ()} -\/ Option for computing normals. By default they are computed.  
\item {\ttfamily obj.\-Compute\-Normals\-On ()} -\/ Option for computing normals. By default they are computed.  
\item {\ttfamily obj.\-Compute\-Normals\-Off ()} -\/ Option for computing normals. By default they are computed.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkbandedpolydatacontourfilter}{}\section{vtk\-Banded\-Poly\-Data\-Contour\-Filter}\label{vtkgraphics_vtkbandedpolydatacontourfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Banded\-Poly\-Data\-Contour\-Filter is a filter that takes as input vtk\-Poly\-Data and produces as output filled contours (also represented as vtk\-Poly\-Data). Filled contours are bands of cells that all have the same cell scalar value, and can therefore be colored the same. The method is also referred to as filled contour generation.

To use this filter you must specify one or more contour values. You can either use the method Set\-Value() to specify each contour value, or use Generate\-Values() to generate a series of evenly spaced contours. Each contour value divides (or clips) the data into two pieces, values below the contour value, and values above it. The scalar values of each band correspond to the specified contour value. Note that if the first and last contour values are not the minimum/maximum contour range, then two extra contour values are added corresponding to the minimum and maximum range values. These extra contour bands can be prevented from being output by turning clipping on.

To create an instance of class vtk\-Banded\-Poly\-Data\-Contour\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBandedPolyDataContourFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Banded\-Poly\-Data\-Contour\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Banded\-Poly\-Data\-Contour\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Banded\-Poly\-Data\-Contour\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Banded\-Poly\-Data\-Contour\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Value (int i, double value)} -\/ Methods to set / get contour values. A single value at a time can be set with Set\-Value(). Multiple contour values can be set with Generate\-Values(). Note that Generate\-Values() generates n values inclusive of the start and end range values.  
\item {\ttfamily double = obj.\-Get\-Value (int i)} -\/ Methods to set / get contour values. A single value at a time can be set with Set\-Value(). Multiple contour values can be set with Generate\-Values(). Note that Generate\-Values() generates n values inclusive of the start and end range values.  
\item {\ttfamily obj.\-Get\-Values (double contour\-Values)} -\/ Methods to set / get contour values. A single value at a time can be set with Set\-Value(). Multiple contour values can be set with Generate\-Values(). Note that Generate\-Values() generates n values inclusive of the start and end range values.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Contours (int number)} -\/ Methods to set / get contour values. A single value at a time can be set with Set\-Value(). Multiple contour values can be set with Generate\-Values(). Note that Generate\-Values() generates n values inclusive of the start and end range values.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Contours ()} -\/ Methods to set / get contour values. A single value at a time can be set with Set\-Value(). Multiple contour values can be set with Generate\-Values(). Note that Generate\-Values() generates n values inclusive of the start and end range values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\mbox{[}2\mbox{]})} -\/ Methods to set / get contour values. A single value at a time can be set with Set\-Value(). Multiple contour values can be set with Generate\-Values(). Note that Generate\-Values() generates n values inclusive of the start and end range values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\-Start, double range\-End)} -\/ Methods to set / get contour values. A single value at a time can be set with Set\-Value(). Multiple contour values can be set with Generate\-Values(). Note that Generate\-Values() generates n values inclusive of the start and end range values.  
\item {\ttfamily obj.\-Set\-Clipping (int )} -\/ Indicate whether to clip outside the range specified by the user. (The range is contour value\mbox{[}0\mbox{]} to contour value\mbox{[}num\-Contours-\/1\mbox{]}.) Clipping means all cells outside of the range specified are not sent to the output.  
\item {\ttfamily int = obj.\-Get\-Clipping ()} -\/ Indicate whether to clip outside the range specified by the user. (The range is contour value\mbox{[}0\mbox{]} to contour value\mbox{[}num\-Contours-\/1\mbox{]}.) Clipping means all cells outside of the range specified are not sent to the output.  
\item {\ttfamily obj.\-Clipping\-On ()} -\/ Indicate whether to clip outside the range specified by the user. (The range is contour value\mbox{[}0\mbox{]} to contour value\mbox{[}num\-Contours-\/1\mbox{]}.) Clipping means all cells outside of the range specified are not sent to the output.  
\item {\ttfamily obj.\-Clipping\-Off ()} -\/ Indicate whether to clip outside the range specified by the user. (The range is contour value\mbox{[}0\mbox{]} to contour value\mbox{[}num\-Contours-\/1\mbox{]}.) Clipping means all cells outside of the range specified are not sent to the output.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode (int )} -\/ Control whether the cell scalars are output as an integer index or a scalar value. If an index, the index refers to the bands produced by the clipping range. If a value, then a scalar value which is a value between clip values is used.  
\item {\ttfamily int = obj.\-Get\-Scalar\-Mode\-Min\-Value ()} -\/ Control whether the cell scalars are output as an integer index or a scalar value. If an index, the index refers to the bands produced by the clipping range. If a value, then a scalar value which is a value between clip values is used.  
\item {\ttfamily int = obj.\-Get\-Scalar\-Mode\-Max\-Value ()} -\/ Control whether the cell scalars are output as an integer index or a scalar value. If an index, the index refers to the bands produced by the clipping range. If a value, then a scalar value which is a value between clip values is used.  
\item {\ttfamily int = obj.\-Get\-Scalar\-Mode ()} -\/ Control whether the cell scalars are output as an integer index or a scalar value. If an index, the index refers to the bands produced by the clipping range. If a value, then a scalar value which is a value between clip values is used.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Index ()} -\/ Control whether the cell scalars are output as an integer index or a scalar value. If an index, the index refers to the bands produced by the clipping range. If a value, then a scalar value which is a value between clip values is used.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Value ()} -\/ Turn on/off a flag to control whether contour edges are generated. Contour edges are the edges between bands. If enabled, they are generated from polygons/triangle strips and placed into the second output (the Contour\-Edges\-Output).  
\item {\ttfamily obj.\-Set\-Generate\-Contour\-Edges (int )} -\/ Turn on/off a flag to control whether contour edges are generated. Contour edges are the edges between bands. If enabled, they are generated from polygons/triangle strips and placed into the second output (the Contour\-Edges\-Output).  
\item {\ttfamily int = obj.\-Get\-Generate\-Contour\-Edges ()} -\/ Turn on/off a flag to control whether contour edges are generated. Contour edges are the edges between bands. If enabled, they are generated from polygons/triangle strips and placed into the second output (the Contour\-Edges\-Output).  
\item {\ttfamily obj.\-Generate\-Contour\-Edges\-On ()} -\/ Turn on/off a flag to control whether contour edges are generated. Contour edges are the edges between bands. If enabled, they are generated from polygons/triangle strips and placed into the second output (the Contour\-Edges\-Output).  
\item {\ttfamily obj.\-Generate\-Contour\-Edges\-Off ()} -\/ Turn on/off a flag to control whether contour edges are generated. Contour edges are the edges between bands. If enabled, they are generated from polygons/triangle strips and placed into the second output (the Contour\-Edges\-Output).  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Contour\-Edges\-Output ()} -\/ Get the second output which contains the edges dividing the contour bands. This output is empty unless Generate\-Contour\-Edges is enabled.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Overload Get\-M\-Time because we delegate to vtk\-Contour\-Values so its modified time must be taken into account.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkblankstructuredgrid}{}\section{vtk\-Blank\-Structured\-Grid}\label{vtkgraphics_vtkblankstructuredgrid}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Blank\-Structured\-Grid is a filter that sets the blanking field in a vtk\-Structured\-Grid dataset. The blanking field is set by examining a specified point attribute data array (e.\-g., scalars) and converting values in the data array to either a \char`\"{}1\char`\"{} (visible) or \char`\"{}0\char`\"{} (blanked) value in the blanking array. The values to be blanked are specified by giving a min/max range. All data values in the data array indicated and laying within the range specified (inclusive on both ends) are translated to a \char`\"{}off\char`\"{} blanking value.

To create an instance of class vtk\-Blank\-Structured\-Grid, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBlankStructuredGrid
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Blank\-Structured\-Grid has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Blank\-Structured\-Grid class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Blank\-Structured\-Grid = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Blank\-Structured\-Grid = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Min\-Blanking\-Value (double )} -\/ Specify the lower data value in the data array specified which will be converted into a \char`\"{}blank\char`\"{} (or off) value in the blanking array.  
\item {\ttfamily double = obj.\-Get\-Min\-Blanking\-Value ()} -\/ Specify the lower data value in the data array specified which will be converted into a \char`\"{}blank\char`\"{} (or off) value in the blanking array.  
\item {\ttfamily obj.\-Set\-Max\-Blanking\-Value (double )} -\/ Specify the upper data value in the data array specified which will be converted into a \char`\"{}blank\char`\"{} (or off) value in the blanking array.  
\item {\ttfamily double = obj.\-Get\-Max\-Blanking\-Value ()} -\/ Specify the upper data value in the data array specified which will be converted into a \char`\"{}blank\char`\"{} (or off) value in the blanking array.  
\item {\ttfamily obj.\-Set\-Array\-Name (string )} -\/ Specify the data array name to use to generate the blanking field. Alternatively, you can specify the array id. (If both are set, the array name takes precedence.)  
\item {\ttfamily string = obj.\-Get\-Array\-Name ()} -\/ Specify the data array name to use to generate the blanking field. Alternatively, you can specify the array id. (If both are set, the array name takes precedence.)  
\item {\ttfamily obj.\-Set\-Array\-Id (int )} -\/ Specify the data array id to use to generate the blanking field. Alternatively, you can specify the array name. (If both are set, the array name takes precedence.)  
\item {\ttfamily int = obj.\-Get\-Array\-Id ()} -\/ Specify the data array id to use to generate the blanking field. Alternatively, you can specify the array name. (If both are set, the array name takes precedence.)  
\item {\ttfamily obj.\-Set\-Component (int )} -\/ Specify the component in the data array to use to generate the blanking field.  
\item {\ttfamily int = obj.\-Get\-Component\-Min\-Value ()} -\/ Specify the component in the data array to use to generate the blanking field.  
\item {\ttfamily int = obj.\-Get\-Component\-Max\-Value ()} -\/ Specify the component in the data array to use to generate the blanking field.  
\item {\ttfamily int = obj.\-Get\-Component ()} -\/ Specify the component in the data array to use to generate the blanking field.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkblankstructuredgridwithimage}{}\section{vtk\-Blank\-Structured\-Grid\-With\-Image}\label{vtkgraphics_vtkblankstructuredgridwithimage}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This filter can be used to set the blanking in a structured grid with an image. The filter takes two inputs\-: the structured grid to blank, and the image used to set the blanking. Make sure that the dimensions of both the image and the structured grid are identical.

Note that the image is interpreted as follows\-: zero values indicate that the structured grid point is blanked; non-\/zero values indicate that the structured grid point is visible. The blanking data must be unsigned char.

To create an instance of class vtk\-Blank\-Structured\-Grid\-With\-Image, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBlankStructuredGridWithImage
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Blank\-Structured\-Grid\-With\-Image has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Blank\-Structured\-Grid\-With\-Image class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Blank\-Structured\-Grid\-With\-Image = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Blank\-Structured\-Grid\-With\-Image = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Blanking\-Input (vtk\-Image\-Data input)} -\/ Set / get the input image used to perform the blanking.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Blanking\-Input ()} -\/ Set / get the input image used to perform the blanking.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkblockidscalars}{}\section{vtk\-Block\-Id\-Scalars}\label{vtkgraphics_vtkblockidscalars}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Block\-Id\-Scalars is a filter that generates scalars using the block index for each block. Note that all sub-\/blocks within a block get the same scalar. The new scalars array is named {\ttfamily Block\-Id\-Scalars}.

To create an instance of class vtk\-Block\-Id\-Scalars, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBlockIdScalars
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Block\-Id\-Scalars has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Block\-Id\-Scalars class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Block\-Id\-Scalars = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Block\-Id\-Scalars = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkboxclipdataset}{}\section{vtk\-Box\-Clip\-Data\-Set}\label{vtkgraphics_vtkboxclipdataset}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Clipping means that is actually 'cuts' through the cells of the dataset, returning tetrahedral cells inside of the box. The output of this filter is an unstructured grid.

This filter can be configured to compute a second output. The second output is the part of the cell that is clipped away. Set the Generate\-Clipped\-Data boolean on if you wish to access this output data.

The vtk\-Box\-Clip\-Data\-Set will triangulate all types of 3\-D cells (i.\-e, create tetrahedra). This is necessary to preserve compatibility across face neighbors.

To use this filter,you can decide if you will be clipping with a box or a hexahedral box. 1) Set orientation if(Set\-Orientation(0))\-: box (parallel with coordinate axis) Set\-Box\-Clip(xmin,xmax,ymin,ymax,zmin,zmax) if(Set\-Orientation(1))\-: hexahedral box (Default) Set\-Box\-Clip(n\mbox{[}0\mbox{]},o\mbox{[}0\mbox{]},n\mbox{[}1\mbox{]},o\mbox{[}1\mbox{]},n\mbox{[}2\mbox{]},o\mbox{[}2\mbox{]},n\mbox{[}3\mbox{]},o\mbox{[}3\mbox{]},n\mbox{[}4\mbox{]},o\mbox{[}4\mbox{]},n\mbox{[}5\mbox{]},o\mbox{[}5\mbox{]}) Plane\-Normal\mbox{[}\mbox{]} normal of each plane Plane\-Point\mbox{[}\mbox{]} point on the plane 2) Apply the Generate\-Clip\-Scalars\-On() 3) Execute clipping Update();

To create an instance of class vtk\-Box\-Clip\-Data\-Set, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBoxClipDataSet
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Box\-Clip\-Data\-Set has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Box\-Clip\-Data\-Set class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Box\-Clip\-Data\-Set = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Box\-Clip\-Data\-Set = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Box\-Clip (double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)}  
\item {\ttfamily obj.\-Set\-Box\-Clip (double n0, double o0, double n1, double o1, double n2, double o2, double n3, double o3, double n4, double o4, double n5, double o5)}  
\item {\ttfamily obj.\-Set\-Generate\-Clip\-Scalars (int )} -\/ If this flag is enabled, then the output scalar values will be interpolated, and not the input scalar data.  
\item {\ttfamily int = obj.\-Get\-Generate\-Clip\-Scalars ()} -\/ If this flag is enabled, then the output scalar values will be interpolated, and not the input scalar data.  
\item {\ttfamily obj.\-Generate\-Clip\-Scalars\-On ()} -\/ If this flag is enabled, then the output scalar values will be interpolated, and not the input scalar data.  
\item {\ttfamily obj.\-Generate\-Clip\-Scalars\-Off ()} -\/ If this flag is enabled, then the output scalar values will be interpolated, and not the input scalar data.  
\item {\ttfamily obj.\-Set\-Generate\-Clipped\-Output (int )} -\/ Control whether a second output is generated. The second output contains the polygonal data that's been clipped away.  
\item {\ttfamily int = obj.\-Get\-Generate\-Clipped\-Output ()} -\/ Control whether a second output is generated. The second output contains the polygonal data that's been clipped away.  
\item {\ttfamily obj.\-Generate\-Clipped\-Output\-On ()} -\/ Control whether a second output is generated. The second output contains the polygonal data that's been clipped away.  
\item {\ttfamily obj.\-Generate\-Clipped\-Output\-Off ()} -\/ Control whether a second output is generated. The second output contains the polygonal data that's been clipped away.  
\item {\ttfamily vtk\-Unstructured\-Grid = obj.\-Get\-Clipped\-Output ()} -\/ Return the Clipped output.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Outputs ()} -\/ Return the Clipped output.  
\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. The locator is used to merge coincident points.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return the mtime also considering the locator.  
\item {\ttfamily int = obj.\-Get\-Orientation ()} -\/ Tells if clipping happens with a box parallel with coordinate axis (0) or with an hexahedral box (1). Initial value is 1.  
\item {\ttfamily obj.\-Set\-Orientation (int )} -\/ Tells if clipping happens with a box parallel with coordinate axis (0) or with an hexahedral box (1). Initial value is 1.  
\item {\ttfamily obj.\-Clip\-Box (vtk\-Points new\-Points, vtk\-Generic\-Cell cell, vtk\-Incremental\-Point\-Locator locator, vtk\-Cell\-Array tets, vtk\-Point\-Data in\-P\-D, vtk\-Point\-Data out\-P\-D, vtk\-Cell\-Data in\-C\-D, vtk\-Id\-Type cell\-Id, vtk\-Cell\-Data out\-C\-D)}  
\item {\ttfamily obj.\-Clip\-Hexahedron (vtk\-Points new\-Points, vtk\-Generic\-Cell cell, vtk\-Incremental\-Point\-Locator locator, vtk\-Cell\-Array tets, vtk\-Point\-Data in\-P\-D, vtk\-Point\-Data out\-P\-D, vtk\-Cell\-Data in\-C\-D, vtk\-Id\-Type cell\-Id, vtk\-Cell\-Data out\-C\-D)}  
\item {\ttfamily obj.\-Clip\-Box2\-D (vtk\-Points new\-Points, vtk\-Generic\-Cell cell, vtk\-Incremental\-Point\-Locator locator, vtk\-Cell\-Array tets, vtk\-Point\-Data in\-P\-D, vtk\-Point\-Data out\-P\-D, vtk\-Cell\-Data in\-C\-D, vtk\-Id\-Type cell\-Id, vtk\-Cell\-Data out\-C\-D)}  
\item {\ttfamily obj.\-Clip\-Hexahedron2\-D (vtk\-Points new\-Points, vtk\-Generic\-Cell cell, vtk\-Incremental\-Point\-Locator locator, vtk\-Cell\-Array tets, vtk\-Point\-Data in\-P\-D, vtk\-Point\-Data out\-P\-D, vtk\-Cell\-Data in\-C\-D, vtk\-Id\-Type cell\-Id, vtk\-Cell\-Data out\-C\-D)}  
\item {\ttfamily obj.\-Clip\-Box1\-D (vtk\-Points new\-Points, vtk\-Generic\-Cell cell, vtk\-Incremental\-Point\-Locator locator, vtk\-Cell\-Array lines, vtk\-Point\-Data in\-P\-D, vtk\-Point\-Data out\-P\-D, vtk\-Cell\-Data in\-C\-D, vtk\-Id\-Type cell\-Id, vtk\-Cell\-Data out\-C\-D)}  
\item {\ttfamily obj.\-Clip\-Hexahedron1\-D (vtk\-Points new\-Points, vtk\-Generic\-Cell cell, vtk\-Incremental\-Point\-Locator locator, vtk\-Cell\-Array lines, vtk\-Point\-Data in\-P\-D, vtk\-Point\-Data out\-P\-D, vtk\-Cell\-Data in\-C\-D, vtk\-Id\-Type cell\-Id, vtk\-Cell\-Data out\-C\-D)}  
\item {\ttfamily obj.\-Clip\-Box0\-D (vtk\-Generic\-Cell cell, vtk\-Incremental\-Point\-Locator locator, vtk\-Cell\-Array verts, vtk\-Point\-Data in\-P\-D, vtk\-Point\-Data out\-P\-D, vtk\-Cell\-Data in\-C\-D, vtk\-Id\-Type cell\-Id, vtk\-Cell\-Data out\-C\-D)}  
\item {\ttfamily obj.\-Clip\-Hexahedron0\-D (vtk\-Generic\-Cell cell, vtk\-Incremental\-Point\-Locator locator, vtk\-Cell\-Array verts, vtk\-Point\-Data in\-P\-D, vtk\-Point\-Data out\-P\-D, vtk\-Cell\-Data in\-C\-D, vtk\-Id\-Type cell\-Id, vtk\-Cell\-Data out\-C\-D)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkbrownianpoints}{}\section{vtk\-Brownian\-Points}\label{vtkgraphics_vtkbrownianpoints}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Brownian\-Points is a filter object that assigns a random vector (i.\-e., magnitude and direction) to each point. The minimum and maximum speed values can be controlled by the user.

To create an instance of class vtk\-Brownian\-Points, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBrownianPoints
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Brownian\-Points has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Brownian\-Points class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Brownian\-Points = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Brownian\-Points = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Minimum\-Speed (double )} -\/ Set the minimum speed value.  
\item {\ttfamily double = obj.\-Get\-Minimum\-Speed\-Min\-Value ()} -\/ Set the minimum speed value.  
\item {\ttfamily double = obj.\-Get\-Minimum\-Speed\-Max\-Value ()} -\/ Set the minimum speed value.  
\item {\ttfamily double = obj.\-Get\-Minimum\-Speed ()} -\/ Set the minimum speed value.  
\item {\ttfamily obj.\-Set\-Maximum\-Speed (double )} -\/ Set the maximum speed value.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Speed\-Min\-Value ()} -\/ Set the maximum speed value.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Speed\-Max\-Value ()} -\/ Set the maximum speed value.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Speed ()} -\/ Set the maximum speed value.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkbutterflysubdivisionfilter}{}\section{vtk\-Butterfly\-Subdivision\-Filter}\label{vtkgraphics_vtkbutterflysubdivisionfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Butterfly\-Subdivision\-Filter is an interpolating subdivision scheme that creates four new triangles for each triangle in the mesh. The user can specify the Number\-Of\-Subdivisions. This filter implements the 8-\/point butterfly scheme described in\-: Zorin, D., Schroder, P., and Sweldens, W., \char`\"{}\-Interpolating Subdivisions for Meshes with Arbitrary
 Topology,\char`\"{} Computer Graphics Proceedings, Annual Conference Series, 1996, A\-C\-M S\-I\-G\-G\-R\-A\-P\-H, pp.\-189-\/192. This scheme improves previous butterfly subdivisions with special treatment of vertices with valence other than 6.

Currently, the filter only operates on triangles. Users should use the vtk\-Triangle\-Filter to triangulate meshes that contain polygons or triangle strips.

The filter interpolates point data using the same scheme. New triangles created at a subdivision step will have the cell data of their parent cell.

To create an instance of class vtk\-Butterfly\-Subdivision\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkButterflySubdivisionFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Butterfly\-Subdivision\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Butterfly\-Subdivision\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Construct object with Number\-Of\-Subdivisions set to 1.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Construct object with Number\-Of\-Subdivisions set to 1.  
\item {\ttfamily vtk\-Butterfly\-Subdivision\-Filter = obj.\-New\-Instance ()} -\/ Construct object with Number\-Of\-Subdivisions set to 1.  
\item {\ttfamily vtk\-Butterfly\-Subdivision\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Construct object with Number\-Of\-Subdivisions set to 1.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkbuttonsource}{}\section{vtk\-Button\-Source}\label{vtkgraphics_vtkbuttonsource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Button\-Source is an abstract class that defines an A\-P\-I for creating \char`\"{}button-\/like\char`\"{} objects in V\-T\-K. A button is a geometry with a rectangular region that can be textured. The button is divided into two regions\-: the texture region and the shoulder region. The points in both regions are assigned texture coordinates. The texture region has texture coordinates consistent with the image to be placed on it. All points in the shoulder regions are assigned a texture coordinate specified by the user. In this way the shoulder region can be colored by the texture.

Creating a vtk\-Button\-Source requires specifying its center point. (Subclasses have other attributes that must be set to control the shape of the button.) You must also specify how to control the shape of the texture region; i.\-e., wheter to size the texture region proportional to the texture dimensions or whether to size the texture region proportional to the button. Also, buttons can be created single sided are mirrored to create two-\/sided buttons.

To create an instance of class vtk\-Button\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkButtonSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Button\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Button\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Button\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Button\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Center (double , double , double )} -\/ Specify a point defining the origin (center) of the button.  
\item {\ttfamily obj.\-Set\-Center (double a\mbox{[}3\mbox{]})} -\/ Specify a point defining the origin (center) of the button.  
\item {\ttfamily double = obj. Get\-Center ()} -\/ Specify a point defining the origin (center) of the button.  
\item {\ttfamily obj.\-Set\-Texture\-Style (int )} -\/ Set/\-Get the style of the texture region\-: whether to size it according to the x-\/y dimensions of the texture, or whether to make the texture region proportional to the width/height of the button.  
\item {\ttfamily int = obj.\-Get\-Texture\-Style\-Min\-Value ()} -\/ Set/\-Get the style of the texture region\-: whether to size it according to the x-\/y dimensions of the texture, or whether to make the texture region proportional to the width/height of the button.  
\item {\ttfamily int = obj.\-Get\-Texture\-Style\-Max\-Value ()} -\/ Set/\-Get the style of the texture region\-: whether to size it according to the x-\/y dimensions of the texture, or whether to make the texture region proportional to the width/height of the button.  
\item {\ttfamily int = obj.\-Get\-Texture\-Style ()} -\/ Set/\-Get the style of the texture region\-: whether to size it according to the x-\/y dimensions of the texture, or whether to make the texture region proportional to the width/height of the button.  
\item {\ttfamily obj.\-Set\-Texture\-Style\-To\-Fit\-Image ()} -\/ Set/\-Get the style of the texture region\-: whether to size it according to the x-\/y dimensions of the texture, or whether to make the texture region proportional to the width/height of the button.  
\item {\ttfamily obj.\-Set\-Texture\-Style\-To\-Proportional ()} -\/ Set/get the texture dimension. This needs to be set if the texture style is set to fit the image.  
\item {\ttfamily obj.\-Set\-Texture\-Dimensions (int , int )} -\/ Set/get the texture dimension. This needs to be set if the texture style is set to fit the image.  
\item {\ttfamily obj.\-Set\-Texture\-Dimensions (int a\mbox{[}2\mbox{]})} -\/ Set/get the texture dimension. This needs to be set if the texture style is set to fit the image.  
\item {\ttfamily int = obj. Get\-Texture\-Dimensions ()} -\/ Set/get the texture dimension. This needs to be set if the texture style is set to fit the image.  
\item {\ttfamily obj.\-Set\-Shoulder\-Texture\-Coordinate (double , double )} -\/ Set/\-Get the default texture coordinate to set the shoulder region to.  
\item {\ttfamily obj.\-Set\-Shoulder\-Texture\-Coordinate (double a\mbox{[}2\mbox{]})} -\/ Set/\-Get the default texture coordinate to set the shoulder region to.  
\item {\ttfamily double = obj. Get\-Shoulder\-Texture\-Coordinate ()} -\/ Set/\-Get the default texture coordinate to set the shoulder region to.  
\item {\ttfamily obj.\-Set\-Two\-Sided (int )} -\/ Indicate whether the button is single or double sided. A double sided button can be viewed from two sides...it looks sort of like a \char`\"{}pill.\char`\"{} A single-\/sided button is meant to viewed from a single side; it looks like a \char`\"{}clam-\/shell.\char`\"{}  
\item {\ttfamily int = obj.\-Get\-Two\-Sided ()} -\/ Indicate whether the button is single or double sided. A double sided button can be viewed from two sides...it looks sort of like a \char`\"{}pill.\char`\"{} A single-\/sided button is meant to viewed from a single side; it looks like a \char`\"{}clam-\/shell.\char`\"{}  
\item {\ttfamily obj.\-Two\-Sided\-On ()} -\/ Indicate whether the button is single or double sided. A double sided button can be viewed from two sides...it looks sort of like a \char`\"{}pill.\char`\"{} A single-\/sided button is meant to viewed from a single side; it looks like a \char`\"{}clam-\/shell.\char`\"{}  
\item {\ttfamily obj.\-Two\-Sided\-Off ()} -\/ Indicate whether the button is single or double sided. A double sided button can be viewed from two sides...it looks sort of like a \char`\"{}pill.\char`\"{} A single-\/sided button is meant to viewed from a single side; it looks like a \char`\"{}clam-\/shell.\char`\"{}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkcellcenters}{}\section{vtk\-Cell\-Centers}\label{vtkgraphics_vtkcellcenters}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Cell\-Centers is a filter that takes as input any dataset and generates on output points at the center of the cells in the dataset. These points can be used for placing glyphs (vtk\-Glyph3\-D) or labeling (vtk\-Labeled\-Data\-Mapper). (The center is the parametric center of the cell, not necessarily the geometric or bounding box center.) The cell attributes will be associated with the points on output.

To create an instance of class vtk\-Cell\-Centers, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCellCenters
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Cell\-Centers has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Cell\-Centers class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Cell\-Centers = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Cell\-Centers = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Vertex\-Cells (int )} -\/ Enable/disable the generation of vertex cells. The default is Off.  
\item {\ttfamily int = obj.\-Get\-Vertex\-Cells ()} -\/ Enable/disable the generation of vertex cells. The default is Off.  
\item {\ttfamily obj.\-Vertex\-Cells\-On ()} -\/ Enable/disable the generation of vertex cells. The default is Off.  
\item {\ttfamily obj.\-Vertex\-Cells\-Off ()} -\/ Enable/disable the generation of vertex cells. The default is Off.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkcelldatatopointdata}{}\section{vtk\-Cell\-Data\-To\-Point\-Data}\label{vtkgraphics_vtkcelldatatopointdata}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Cell\-Data\-To\-Point\-Data is a filter that transforms cell data (i.\-e., data specified per cell) into point data (i.\-e., data specified at cell points). The method of transformation is based on averaging the data values of all cells using a particular point. Optionally, the input cell data can be passed through to the output as well.

To create an instance of class vtk\-Cell\-Data\-To\-Point\-Data, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCellDataToPointData
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Cell\-Data\-To\-Point\-Data has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Cell\-Data\-To\-Point\-Data class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Cell\-Data\-To\-Point\-Data = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Cell\-Data\-To\-Point\-Data = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Pass\-Cell\-Data (int )} -\/ Control whether the input cell data is to be passed to the output. If on, then the input cell data is passed through to the output; otherwise, only generated point data is placed into the output.  
\item {\ttfamily int = obj.\-Get\-Pass\-Cell\-Data ()} -\/ Control whether the input cell data is to be passed to the output. If on, then the input cell data is passed through to the output; otherwise, only generated point data is placed into the output.  
\item {\ttfamily obj.\-Pass\-Cell\-Data\-On ()} -\/ Control whether the input cell data is to be passed to the output. If on, then the input cell data is passed through to the output; otherwise, only generated point data is placed into the output.  
\item {\ttfamily obj.\-Pass\-Cell\-Data\-Off ()} -\/ Control whether the input cell data is to be passed to the output. If on, then the input cell data is passed through to the output; otherwise, only generated point data is placed into the output.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkcellderivatives}{}\section{vtk\-Cell\-Derivatives}\label{vtkgraphics_vtkcellderivatives}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Cell\-Derivatives is a filter that computes derivatives of scalars and vectors at the center of cells. You can choose to generate different output including the scalar gradient (a vector), computed tensor vorticity (a vector), gradient of input vectors (a tensor), and strain matrix of the input vectors (a tensor); or you may choose to pass data through to the output.

Note that it is assumed that on input scalars and vector point data is available, which are then used to generate cell vectors and tensors. (The interpolation functions of the cells are used to compute the derivatives which is why point data is required.)

To create an instance of class vtk\-Cell\-Derivatives, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCellDerivatives
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Cell\-Derivatives has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Cell\-Derivatives class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Cell\-Derivatives = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Cell\-Derivatives = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Vector\-Mode (int )} -\/ Control how the filter works to generate vector cell data. You can choose to pass the input cell vectors, compute the gradient of the input scalars, or extract the vorticity of the computed vector gradient tensor. By default (Vector\-Mode\-To\-Compute\-Gradient), the filter will take the gradient of the input scalar data.  
\item {\ttfamily int = obj.\-Get\-Vector\-Mode ()} -\/ Control how the filter works to generate vector cell data. You can choose to pass the input cell vectors, compute the gradient of the input scalars, or extract the vorticity of the computed vector gradient tensor. By default (Vector\-Mode\-To\-Compute\-Gradient), the filter will take the gradient of the input scalar data.  
\item {\ttfamily obj.\-Set\-Vector\-Mode\-To\-Pass\-Vectors ()} -\/ Control how the filter works to generate vector cell data. You can choose to pass the input cell vectors, compute the gradient of the input scalars, or extract the vorticity of the computed vector gradient tensor. By default (Vector\-Mode\-To\-Compute\-Gradient), the filter will take the gradient of the input scalar data.  
\item {\ttfamily obj.\-Set\-Vector\-Mode\-To\-Compute\-Gradient ()} -\/ Control how the filter works to generate vector cell data. You can choose to pass the input cell vectors, compute the gradient of the input scalars, or extract the vorticity of the computed vector gradient tensor. By default (Vector\-Mode\-To\-Compute\-Gradient), the filter will take the gradient of the input scalar data.  
\item {\ttfamily obj.\-Set\-Vector\-Mode\-To\-Compute\-Vorticity ()} -\/ Control how the filter works to generate vector cell data. You can choose to pass the input cell vectors, compute the gradient of the input scalars, or extract the vorticity of the computed vector gradient tensor. By default (Vector\-Mode\-To\-Compute\-Gradient), the filter will take the gradient of the input scalar data.  
\item {\ttfamily string = obj.\-Get\-Vector\-Mode\-As\-String ()} -\/ Control how the filter works to generate vector cell data. You can choose to pass the input cell vectors, compute the gradient of the input scalars, or extract the vorticity of the computed vector gradient tensor. By default (Vector\-Mode\-To\-Compute\-Gradient), the filter will take the gradient of the input scalar data.  
\item {\ttfamily obj.\-Set\-Tensor\-Mode (int )} -\/ Control how the filter works to generate tensor cell data. You can choose to pass the input cell tensors, compute the gradient of the input vectors, or compute the strain tensor of the vector gradient tensor. By default (Tensor\-Mode\-To\-Compute\-Gradient), the filter will take the gradient of the vector data to construct a tensor.  
\item {\ttfamily int = obj.\-Get\-Tensor\-Mode ()} -\/ Control how the filter works to generate tensor cell data. You can choose to pass the input cell tensors, compute the gradient of the input vectors, or compute the strain tensor of the vector gradient tensor. By default (Tensor\-Mode\-To\-Compute\-Gradient), the filter will take the gradient of the vector data to construct a tensor.  
\item {\ttfamily obj.\-Set\-Tensor\-Mode\-To\-Pass\-Tensors ()} -\/ Control how the filter works to generate tensor cell data. You can choose to pass the input cell tensors, compute the gradient of the input vectors, or compute the strain tensor of the vector gradient tensor. By default (Tensor\-Mode\-To\-Compute\-Gradient), the filter will take the gradient of the vector data to construct a tensor.  
\item {\ttfamily obj.\-Set\-Tensor\-Mode\-To\-Compute\-Gradient ()} -\/ Control how the filter works to generate tensor cell data. You can choose to pass the input cell tensors, compute the gradient of the input vectors, or compute the strain tensor of the vector gradient tensor. By default (Tensor\-Mode\-To\-Compute\-Gradient), the filter will take the gradient of the vector data to construct a tensor.  
\item {\ttfamily obj.\-Set\-Tensor\-Mode\-To\-Compute\-Strain ()} -\/ Control how the filter works to generate tensor cell data. You can choose to pass the input cell tensors, compute the gradient of the input vectors, or compute the strain tensor of the vector gradient tensor. By default (Tensor\-Mode\-To\-Compute\-Gradient), the filter will take the gradient of the vector data to construct a tensor.  
\item {\ttfamily string = obj.\-Get\-Tensor\-Mode\-As\-String ()} -\/ Control how the filter works to generate tensor cell data. You can choose to pass the input cell tensors, compute the gradient of the input vectors, or compute the strain tensor of the vector gradient tensor. By default (Tensor\-Mode\-To\-Compute\-Gradient), the filter will take the gradient of the vector data to construct a tensor.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkcleanpolydata}{}\section{vtk\-Clean\-Poly\-Data}\label{vtkgraphics_vtkcleanpolydata}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Clean\-Poly\-Data is a filter that takes polygonal data as input and generates polygonal data as output. vtk\-Clean\-Poly\-Data can merge duplicate points (within specified tolerance and if enabled), eliminate points that are not used, and if enabled, transform degenerate cells into appropriate forms (for example, a triangle is converted into a line if two points of triangle are merged).

Conversion of degenerate cells is controlled by the flags Convert\-Lines\-To\-Points, Convert\-Polys\-To\-Lines, Convert\-Strips\-To\-Polys which act cumulatively such that a degenerate strip may become a poly. The full set is Line with 1 points -\/$>$ Vert (if Convert\-Lines\-To\-Points) Poly with 2 points -\/$>$ Line (if Convert\-Polys\-To\-Lines) Poly with 1 points -\/$>$ Vert (if Convert\-Polys\-To\-Lines \&\& Convert\-Lines\-To\-Points) Strp with 3 points -\/$>$ Poly (if Convert\-Strips\-To\-Polys) Strp with 2 points -\/$>$ Line (if Convert\-Strips\-To\-Polys \&\& Convert\-Polys\-To\-Lines) Strp with 1 points -\/$>$ Vert (if Convert\-Strips\-To\-Polys \&\& Convert\-Polys\-To\-Lines \&\& Convert\-Lines\-To\-Points)

If tolerance is specified precisely=0.\-0, then vtk\-Clean\-Poly\-Data will use the vtk\-Merge\-Points object to merge points (which is faster). Otherwise the slower vtk\-Incremental\-Point\-Locator is used. Before inserting points into the point locator, this class calls a function Operate\-On\-Point which can be used (in subclasses) to further refine the cleaning process. See vtk\-Quantize\-Poly\-Data\-Points.

Note that merging of points can be disabled. In this case, a point locator will not be used, and points that are not used by any cells will be eliminated, but never merged.

To create an instance of class vtk\-Clean\-Poly\-Data, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCleanPolyData
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Clean\-Poly\-Data has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Clean\-Poly\-Data class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Clean\-Poly\-Data = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Clean\-Poly\-Data = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Tolerance\-Is\-Absolute (int )} -\/ By default Tolerance\-Is\-Absolute is false and Tolerance is a fraction of Bounding box diagonal, if true, Absolute\-Tolerance is used when adding points to locator (merging)  
\item {\ttfamily obj.\-Tolerance\-Is\-Absolute\-On ()} -\/ By default Tolerance\-Is\-Absolute is false and Tolerance is a fraction of Bounding box diagonal, if true, Absolute\-Tolerance is used when adding points to locator (merging)  
\item {\ttfamily obj.\-Tolerance\-Is\-Absolute\-Off ()} -\/ By default Tolerance\-Is\-Absolute is false and Tolerance is a fraction of Bounding box diagonal, if true, Absolute\-Tolerance is used when adding points to locator (merging)  
\item {\ttfamily int = obj.\-Get\-Tolerance\-Is\-Absolute ()} -\/ By default Tolerance\-Is\-Absolute is false and Tolerance is a fraction of Bounding box diagonal, if true, Absolute\-Tolerance is used when adding points to locator (merging)  
\item {\ttfamily obj.\-Set\-Tolerance (double )} -\/ Specify tolerance in terms of fraction of bounding box length.  
\item {\ttfamily double = obj.\-Get\-Tolerance\-Min\-Value ()} -\/ Specify tolerance in terms of fraction of bounding box length.  
\item {\ttfamily double = obj.\-Get\-Tolerance\-Max\-Value ()} -\/ Specify tolerance in terms of fraction of bounding box length.  
\item {\ttfamily double = obj.\-Get\-Tolerance ()} -\/ Specify tolerance in terms of fraction of bounding box length.  
\item {\ttfamily obj.\-Set\-Absolute\-Tolerance (double )} -\/ Specify tolerance in absolute terms  
\item {\ttfamily double = obj.\-Get\-Absolute\-Tolerance\-Min\-Value ()} -\/ Specify tolerance in absolute terms  
\item {\ttfamily double = obj.\-Get\-Absolute\-Tolerance\-Max\-Value ()} -\/ Specify tolerance in absolute terms  
\item {\ttfamily double = obj.\-Get\-Absolute\-Tolerance ()} -\/ Specify tolerance in absolute terms  
\item {\ttfamily obj.\-Set\-Convert\-Lines\-To\-Points (int )} -\/ Turn on/off conversion of degenerate lines to points  
\item {\ttfamily obj.\-Convert\-Lines\-To\-Points\-On ()} -\/ Turn on/off conversion of degenerate lines to points  
\item {\ttfamily obj.\-Convert\-Lines\-To\-Points\-Off ()} -\/ Turn on/off conversion of degenerate lines to points  
\item {\ttfamily int = obj.\-Get\-Convert\-Lines\-To\-Points ()} -\/ Turn on/off conversion of degenerate lines to points  
\item {\ttfamily obj.\-Set\-Convert\-Polys\-To\-Lines (int )} -\/ Turn on/off conversion of degenerate polys to lines  
\item {\ttfamily obj.\-Convert\-Polys\-To\-Lines\-On ()} -\/ Turn on/off conversion of degenerate polys to lines  
\item {\ttfamily obj.\-Convert\-Polys\-To\-Lines\-Off ()} -\/ Turn on/off conversion of degenerate polys to lines  
\item {\ttfamily int = obj.\-Get\-Convert\-Polys\-To\-Lines ()} -\/ Turn on/off conversion of degenerate polys to lines  
\item {\ttfamily obj.\-Set\-Convert\-Strips\-To\-Polys (int )} -\/ Turn on/off conversion of degenerate strips to polys  
\item {\ttfamily obj.\-Convert\-Strips\-To\-Polys\-On ()} -\/ Turn on/off conversion of degenerate strips to polys  
\item {\ttfamily obj.\-Convert\-Strips\-To\-Polys\-Off ()} -\/ Turn on/off conversion of degenerate strips to polys  
\item {\ttfamily int = obj.\-Get\-Convert\-Strips\-To\-Polys ()} -\/ Turn on/off conversion of degenerate strips to polys  
\item {\ttfamily obj.\-Set\-Point\-Merging (int )} -\/ Set/\-Get a boolean value that controls whether point merging is performed. If on, a locator will be used, and points laying within the appropriate tolerance may be merged. If off, points are never merged. By default, merging is on.  
\item {\ttfamily int = obj.\-Get\-Point\-Merging ()} -\/ Set/\-Get a boolean value that controls whether point merging is performed. If on, a locator will be used, and points laying within the appropriate tolerance may be merged. If off, points are never merged. By default, merging is on.  
\item {\ttfamily obj.\-Point\-Merging\-On ()} -\/ Set/\-Get a boolean value that controls whether point merging is performed. If on, a locator will be used, and points laying within the appropriate tolerance may be merged. If off, points are never merged. By default, merging is on.  
\item {\ttfamily obj.\-Point\-Merging\-Off ()} -\/ Set/\-Get a boolean value that controls whether point merging is performed. If on, a locator will be used, and points laying within the appropriate tolerance may be merged. If off, points are never merged. By default, merging is on.  
\item {\ttfamily obj.\-Set\-Locator (vtk\-Incremental\-Point\-Locator locator)} -\/ Set/\-Get a spatial locator for speeding the search process. 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 speeding the search process. By default an instance of vtk\-Merge\-Points is used.  
\item {\ttfamily obj.\-Create\-Default\-Locator (vtk\-Poly\-Data input)} -\/ Create default locator. Used to create one when none is specified.  
\item {\ttfamily obj.\-Release\-Locator ()} -\/ Get the M\-Time of this object also considering the locator.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Get the M\-Time of this object also considering the locator.  
\item {\ttfamily obj.\-Operate\-On\-Point (double in\mbox{[}3\mbox{]}, double out\mbox{[}3\mbox{]})} -\/ Perform operation on a point  
\item {\ttfamily obj.\-Operate\-On\-Bounds (double in\mbox{[}6\mbox{]}, double out\mbox{[}6\mbox{]})} -\/ Perform operation on bounds  
\item {\ttfamily obj.\-Set\-Piece\-Invariant (int )}  
\item {\ttfamily int = obj.\-Get\-Piece\-Invariant ()}  
\item {\ttfamily obj.\-Piece\-Invariant\-On ()}  
\item {\ttfamily obj.\-Piece\-Invariant\-Off ()}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkclipconvexpolydata}{}\section{vtk\-Clip\-Convex\-Poly\-Data}\label{vtkgraphics_vtkclipconvexpolydata}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Clip\-Convex\-Poly\-Data is a filter that clips a convex polydata with a set of planes. Its main usage is for clipping a bounding volume with frustum planes (used later one in volume rendering).

To create an instance of class vtk\-Clip\-Convex\-Poly\-Data, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkClipConvexPolyData
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Clip\-Convex\-Poly\-Data has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Clip\-Convex\-Poly\-Data class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Clip\-Convex\-Poly\-Data = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Clip\-Convex\-Poly\-Data = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Planes (vtk\-Plane\-Collection planes)} -\/ Set all the planes at once using a vtk\-Planes implicit function. This also sets the D value.  
\item {\ttfamily vtk\-Plane\-Collection = obj.\-Get\-Planes ()} -\/ Set all the planes at once using a vtk\-Planes implicit function. This also sets the D value.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Redefines this method, as this filter depends on time of its components (planes)  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkclipdataset}{}\section{vtk\-Clip\-Data\-Set}\label{vtkgraphics_vtkclipdataset}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Clip\-Data\-Set is a filter that clips any type of dataset using either any subclass of vtk\-Implicit\-Function, or the input scalar data. Clipping means that it actually \char`\"{}cuts\char`\"{} through the cells of the dataset, returning everything inside of the specified implicit function (or greater than the scalar value) including \char`\"{}pieces\char`\"{} of a cell. (Compare this with vtk\-Extract\-Geometry, which pulls out entire, uncut cells.) The output of this filter is an unstructured grid.

To use this filter, you must decide if you will be clipping with an implicit function, or whether you will be using the input scalar data. If you want to clip with an implicit function, you must\-: 1) define an implicit function 2) set it with the Set\-Clip\-Function method 3) apply the Generate\-Clip\-Scalars\-On method If a Clip\-Function is not specified, or Generate\-Clip\-Scalars is off (the default), then the input's scalar data will be used to clip the polydata.

You can also specify a scalar value, which is used to decide what is inside and outside of the implicit function. You can also reverse the sense of what inside/outside is by setting the Inside\-Out instance variable. (The clipping algorithm proceeds by computing an implicit function value or using the input scalar data for each point in the dataset. This is compared to the scalar value to determine inside/outside.)

This filter can be configured to compute a second output. The second output is the part of the cell that is clipped away. Set the Generate\-Clipped\-Data boolean on if you wish to access this output data.

To create an instance of class vtk\-Clip\-Data\-Set, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkClipDataSet
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Clip\-Data\-Set has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Clip\-Data\-Set class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Clip\-Data\-Set = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Clip\-Data\-Set = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Value (double )} -\/ Set the clipping value of the implicit function (if clipping with implicit function) or scalar value (if clipping with scalars). The default value is 0.\-0. This value is ignored if Use\-Value\-As\-Offset is true and a clip function is defined.  
\item {\ttfamily double = obj.\-Get\-Value ()} -\/ Set the clipping value of the implicit function (if clipping with implicit function) or scalar value (if clipping with scalars). The default value is 0.\-0. This value is ignored if Use\-Value\-As\-Offset is true and a clip function is defined.  
\item {\ttfamily obj.\-Set\-Use\-Value\-As\-Offset (bool )} -\/ If Use\-Value\-As\-Offset is true, Value is used as an offset parameter to the implicit function. Otherwise, Value is used only when clipping using a scalar array. Default is true.  
\item {\ttfamily bool = obj.\-Get\-Use\-Value\-As\-Offset ()} -\/ If Use\-Value\-As\-Offset is true, Value is used as an offset parameter to the implicit function. Otherwise, Value is used only when clipping using a scalar array. Default is true.  
\item {\ttfamily obj.\-Use\-Value\-As\-Offset\-On ()} -\/ If Use\-Value\-As\-Offset is true, Value is used as an offset parameter to the implicit function. Otherwise, Value is used only when clipping using a scalar array. Default is true.  
\item {\ttfamily obj.\-Use\-Value\-As\-Offset\-Off ()} -\/ If Use\-Value\-As\-Offset is true, Value is used as an offset parameter to the implicit function. Otherwise, Value is used only when clipping using a scalar array. Default is true.  
\item {\ttfamily obj.\-Set\-Inside\-Out (int )} -\/ Set/\-Get the Inside\-Out flag. When off, a vertex is considered inside the implicit function if its value is greater than the Value ivar. When Inside\-Outside is turned on, a vertex is considered inside the implicit function if its implicit function value is less than or equal to the Value ivar. Inside\-Out is off by default.  
\item {\ttfamily int = obj.\-Get\-Inside\-Out ()} -\/ Set/\-Get the Inside\-Out flag. When off, a vertex is considered inside the implicit function if its value is greater than the Value ivar. When Inside\-Outside is turned on, a vertex is considered inside the implicit function if its implicit function value is less than or equal to the Value ivar. Inside\-Out is off by default.  
\item {\ttfamily obj.\-Inside\-Out\-On ()} -\/ Set/\-Get the Inside\-Out flag. When off, a vertex is considered inside the implicit function if its value is greater than the Value ivar. When Inside\-Outside is turned on, a vertex is considered inside the implicit function if its implicit function value is less than or equal to the Value ivar. Inside\-Out is off by default.  
\item {\ttfamily obj.\-Inside\-Out\-Off ()} -\/ Set/\-Get the Inside\-Out flag. When off, a vertex is considered inside the implicit function if its value is greater than the Value ivar. When Inside\-Outside is turned on, a vertex is considered inside the implicit function if its implicit function value is less than or equal to the Value ivar. Inside\-Out is off by default.  
\item {\ttfamily obj.\-Set\-Clip\-Function (vtk\-Implicit\-Function )}  
\item {\ttfamily vtk\-Implicit\-Function = obj.\-Get\-Clip\-Function ()}  
\item {\ttfamily obj.\-Set\-Generate\-Clip\-Scalars (int )} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data. If you enable this flag but do not provide an implicit function an error will be reported.  
\item {\ttfamily int = obj.\-Get\-Generate\-Clip\-Scalars ()} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data. If you enable this flag but do not provide an implicit function an error will be reported.  
\item {\ttfamily obj.\-Generate\-Clip\-Scalars\-On ()} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data. If you enable this flag but do not provide an implicit function an error will be reported.  
\item {\ttfamily obj.\-Generate\-Clip\-Scalars\-Off ()} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data. If you enable this flag but do not provide an implicit function an error will be reported.  
\item {\ttfamily obj.\-Set\-Generate\-Clipped\-Output (int )} -\/ Control whether a second output is generated. The second output contains the polygonal data that's been clipped away.  
\item {\ttfamily int = obj.\-Get\-Generate\-Clipped\-Output ()} -\/ Control whether a second output is generated. The second output contains the polygonal data that's been clipped away.  
\item {\ttfamily obj.\-Generate\-Clipped\-Output\-On ()} -\/ Control whether a second output is generated. The second output contains the polygonal data that's been clipped away.  
\item {\ttfamily obj.\-Generate\-Clipped\-Output\-Off ()} -\/ Control whether a second output is generated. The second output contains the polygonal data that's been clipped away.  
\item {\ttfamily obj.\-Set\-Merge\-Tolerance (double )} -\/ Set the tolerance for merging clip intersection points that are near the vertices of cells. This tolerance is used to prevent the generation of degenerate primitives. Note that only 3\-D cells actually use this instance variable.  
\item {\ttfamily double = obj.\-Get\-Merge\-Tolerance\-Min\-Value ()} -\/ Set the tolerance for merging clip intersection points that are near the vertices of cells. This tolerance is used to prevent the generation of degenerate primitives. Note that only 3\-D cells actually use this instance variable.  
\item {\ttfamily double = obj.\-Get\-Merge\-Tolerance\-Max\-Value ()} -\/ Set the tolerance for merging clip intersection points that are near the vertices of cells. This tolerance is used to prevent the generation of degenerate primitives. Note that only 3\-D cells actually use this instance variable.  
\item {\ttfamily double = obj.\-Get\-Merge\-Tolerance ()} -\/ Set the tolerance for merging clip intersection points that are near the vertices of cells. This tolerance is used to prevent the generation of degenerate primitives. Note that only 3\-D cells actually use this instance variable.  
\item {\ttfamily vtk\-Unstructured\-Grid = obj.\-Get\-Clipped\-Output ()} -\/ Return the Clipped output.  
\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. The locator is used to merge coincident points.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return the mtime also considering the locator and clip function.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkcliphyperoctree}{}\section{vtk\-Clip\-Hyper\-Octree}\label{vtkgraphics_vtkcliphyperoctree}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Clip\-Hyper\-Octree is a filter that clips an hyperoctree using either any subclass of vtk\-Implicit\-Function, or the input scalar data. Clipping means that it actually \char`\"{}cuts\char`\"{} through the leaves (cells) of the hyperoctree, returning everything inside of the specified implicit function (or greater than the scalar value) including \char`\"{}pieces\char`\"{} of a cell. (Compare this with vtk\-Extract\-Geometry, which pulls out entire, uncut cells.) The output of this filter is an unstructured grid.

To use this filter, you must decide if you will be clipping with an implicit function, or whether you will be using the input scalar data. If you want to clip with an implicit function, you must\-: 1) define an implicit function 2) set it with the Set\-Clip\-Function method 3) apply the Generate\-Clip\-Scalars\-On method If a Clip\-Function is not specified, or Generate\-Clip\-Scalars is off (the default), then the input's scalar data will be used to clip the polydata.

You can also specify a scalar value, which is used to decide what is inside and outside of the implicit function. You can also reverse the sense of what inside/outside is by setting the Inside\-Out instance variable. (The clipping algorithm proceeds by computing an implicit function value or using the input scalar data for each point in the dataset. This is compared to the scalar value to determine inside/outside.)

This filter can be configured to compute a second output. The second output is the part of the cell that is clipped away. Set the Generate\-Clipped\-Data boolean on if you wish to access this output data.

To create an instance of class vtk\-Clip\-Hyper\-Octree, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkClipHyperOctree
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Clip\-Hyper\-Octree has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Clip\-Hyper\-Octree class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Clip\-Hyper\-Octree = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Clip\-Hyper\-Octree = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Value (double )} -\/ Set the clipping value of the implicit function (if clipping with implicit function) or scalar value (if clipping with scalars). The default value is 0.\-0.  
\item {\ttfamily double = obj.\-Get\-Value ()} -\/ Set the clipping value of the implicit function (if clipping with implicit function) or scalar value (if clipping with scalars). The default value is 0.\-0.  
\item {\ttfamily obj.\-Set\-Inside\-Out (int )} -\/ Set/\-Get the Inside\-Out flag. When off, a vertex is considered inside the implicit function if its value is greater than the Value ivar. When Inside\-Outside is turned on, a vertex is considered inside the implicit function if its implicit function value is less than or equal to the Value ivar. Inside\-Out is off by default.  
\item {\ttfamily int = obj.\-Get\-Inside\-Out ()} -\/ Set/\-Get the Inside\-Out flag. When off, a vertex is considered inside the implicit function if its value is greater than the Value ivar. When Inside\-Outside is turned on, a vertex is considered inside the implicit function if its implicit function value is less than or equal to the Value ivar. Inside\-Out is off by default.  
\item {\ttfamily obj.\-Inside\-Out\-On ()} -\/ Set/\-Get the Inside\-Out flag. When off, a vertex is considered inside the implicit function if its value is greater than the Value ivar. When Inside\-Outside is turned on, a vertex is considered inside the implicit function if its implicit function value is less than or equal to the Value ivar. Inside\-Out is off by default.  
\item {\ttfamily obj.\-Inside\-Out\-Off ()} -\/ Set/\-Get the Inside\-Out flag. When off, a vertex is considered inside the implicit function if its value is greater than the Value ivar. When Inside\-Outside is turned on, a vertex is considered inside the implicit function if its implicit function value is less than or equal to the Value ivar. Inside\-Out is off by default.  
\item {\ttfamily obj.\-Set\-Clip\-Function (vtk\-Implicit\-Function )}  
\item {\ttfamily vtk\-Implicit\-Function = obj.\-Get\-Clip\-Function ()}  
\item {\ttfamily obj.\-Set\-Generate\-Clip\-Scalars (int )} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data. If you enable this flag but do not provide an implicit function an error will be reported.  
\item {\ttfamily int = obj.\-Get\-Generate\-Clip\-Scalars ()} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data. If you enable this flag but do not provide an implicit function an error will be reported.  
\item {\ttfamily obj.\-Generate\-Clip\-Scalars\-On ()} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data. If you enable this flag but do not provide an implicit function an error will be reported.  
\item {\ttfamily obj.\-Generate\-Clip\-Scalars\-Off ()} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data. If you enable this flag but do not provide an implicit function an error will be reported.  
\item {\ttfamily obj.\-Set\-Generate\-Clipped\-Output (int )} -\/ Control whether a second output is generated. The second output contains the polygonal data that's been clipped away.  
\item {\ttfamily int = obj.\-Get\-Generate\-Clipped\-Output ()} -\/ Control whether a second output is generated. The second output contains the polygonal data that's been clipped away.  
\item {\ttfamily obj.\-Generate\-Clipped\-Output\-On ()} -\/ Control whether a second output is generated. The second output contains the polygonal data that's been clipped away.  
\item {\ttfamily obj.\-Generate\-Clipped\-Output\-Off ()} -\/ Control whether a second output is generated. The second output contains the polygonal data that's been clipped away.  
\item {\ttfamily vtk\-Unstructured\-Grid = obj.\-Get\-Clipped\-Output ()} -\/ Return the Clipped output.  
\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. The locator is used to merge coincident points.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return the mtime also considering the locator and clip function.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkclippolydata}{}\section{vtk\-Clip\-Poly\-Data}\label{vtkgraphics_vtkclippolydata}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Clip\-Poly\-Data is a filter that clips polygonal data using either any subclass of vtk\-Implicit\-Function, or the input scalar data. Clipping means that it actually \char`\"{}cuts\char`\"{} through the cells of the dataset, returning everything inside of the specified implicit function (or greater than the scalar value) including \char`\"{}pieces\char`\"{} of a cell. (Compare this with vtk\-Extract\-Geometry, which pulls out entire, uncut cells.) The output of this filter is polygonal data.

To use this filter, you must decide if you will be clipping with an implicit function, or whether you will be using the input scalar data. If you want to clip with an implicit function, you must\-: 1) define an implicit function 2) set it with the Set\-Clip\-Function method 3) apply the Generate\-Clip\-Scalars\-On method If a Clip\-Function is not specified, or Generate\-Clip\-Scalars is off (the default), then the input's scalar data will be used to clip the polydata.

You can also specify a scalar value, which is used to decide what is inside and outside of the implicit function. You can also reverse the sense of what inside/outside is by setting the Inside\-Out instance variable. (The cutting algorithm proceeds by computing an implicit function value or using the input scalar data for each point in the dataset. This is compared to the scalar value to determine inside/outside.)

This filter can be configured to compute a second output. The second output is the polygonal data that is clipped away. Set the Generate\-Clipped\-Data boolean on if you wish to access this output data.

To create an instance of class vtk\-Clip\-Poly\-Data, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkClipPolyData
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Clip\-Poly\-Data has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Clip\-Poly\-Data class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Clip\-Poly\-Data = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Clip\-Poly\-Data = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Value (double )} -\/ Set the clipping value of the implicit function (if clipping with implicit function) or scalar value (if clipping with scalars). The default value is 0.\-0.  
\item {\ttfamily double = obj.\-Get\-Value ()} -\/ Set the clipping value of the implicit function (if clipping with implicit function) or scalar value (if clipping with scalars). The default value is 0.\-0.  
\item {\ttfamily obj.\-Set\-Inside\-Out (int )} -\/ Set/\-Get the Inside\-Out flag. When off, a vertex is considered inside the implicit function if its value is greater than the Value ivar. When Inside\-Outside is turned on, a vertex is considered inside the implicit function if its implicit function value is less than or equal to the Value ivar. Inside\-Out is off by default.  
\item {\ttfamily int = obj.\-Get\-Inside\-Out ()} -\/ Set/\-Get the Inside\-Out flag. When off, a vertex is considered inside the implicit function if its value is greater than the Value ivar. When Inside\-Outside is turned on, a vertex is considered inside the implicit function if its implicit function value is less than or equal to the Value ivar. Inside\-Out is off by default.  
\item {\ttfamily obj.\-Inside\-Out\-On ()} -\/ Set/\-Get the Inside\-Out flag. When off, a vertex is considered inside the implicit function if its value is greater than the Value ivar. When Inside\-Outside is turned on, a vertex is considered inside the implicit function if its implicit function value is less than or equal to the Value ivar. Inside\-Out is off by default.  
\item {\ttfamily obj.\-Inside\-Out\-Off ()} -\/ Set/\-Get the Inside\-Out flag. When off, a vertex is considered inside the implicit function if its value is greater than the Value ivar. When Inside\-Outside is turned on, a vertex is considered inside the implicit function if its implicit function value is less than or equal to the Value ivar. Inside\-Out is off by default.  
\item {\ttfamily obj.\-Set\-Clip\-Function (vtk\-Implicit\-Function )}  
\item {\ttfamily vtk\-Implicit\-Function = obj.\-Get\-Clip\-Function ()}  
\item {\ttfamily obj.\-Set\-Generate\-Clip\-Scalars (int )} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data. If you enable this flag but do not provide an implicit function an error will be reported.  
\item {\ttfamily int = obj.\-Get\-Generate\-Clip\-Scalars ()} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data. If you enable this flag but do not provide an implicit function an error will be reported.  
\item {\ttfamily obj.\-Generate\-Clip\-Scalars\-On ()} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data. If you enable this flag but do not provide an implicit function an error will be reported.  
\item {\ttfamily obj.\-Generate\-Clip\-Scalars\-Off ()} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data. If you enable this flag but do not provide an implicit function an error will be reported.  
\item {\ttfamily obj.\-Set\-Generate\-Clipped\-Output (int )} -\/ Control whether a second output is generated. The second output contains the polygonal data that's been clipped away.  
\item {\ttfamily int = obj.\-Get\-Generate\-Clipped\-Output ()} -\/ Control whether a second output is generated. The second output contains the polygonal data that's been clipped away.  
\item {\ttfamily obj.\-Generate\-Clipped\-Output\-On ()} -\/ Control whether a second output is generated. The second output contains the polygonal data that's been clipped away.  
\item {\ttfamily obj.\-Generate\-Clipped\-Output\-Off ()} -\/ Control whether a second output is generated. The second output contains the polygonal data that's been clipped away.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Clipped\-Output ()} -\/ Return the Clipped output.  
\item {\ttfamily vtk\-Algorithm\-Output = obj.\-Get\-Clipped\-Output\-Port ()} -\/ Specify a spatial locator for merging points. By default, an instance of vtk\-Merge\-Points is used.  
\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. The locator is used to merge coincident points.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return the mtime also considering the locator and clip function.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkclipvolume}{}\section{vtk\-Clip\-Volume}\label{vtkgraphics_vtkclipvolume}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Clip\-Volume is a filter that clips volume data (i.\-e., vtk\-Image\-Data) using either\-: any subclass of vtk\-Implicit\-Function or the input scalar data. The clipping operation cuts through the cells of the dataset--converting 3\-D image data into a 3\-D unstructured grid--returning everything inside of the specified implicit function (or greater than the scalar value). During the clipping the filter will produce pieces of a cell. (Compare this with vtk\-Extract\-Geometry or vtk\-Geometry\-Filter, which produces entire, uncut cells.) The output of this filter is a 3\-D unstructured grid (e.\-g., tetrahedra or other 3\-D cell types).

To use this filter, you must decide if you will be clipping with an implicit function, or whether you will be using the input scalar data. If you want to clip with an implicit function, you must first define and then set the implicit function with the Set\-Clip\-Function() method. Otherwise, you must make sure input scalar data is available. You can also specify a scalar value, which is used to decide what is inside and outside of the implicit function. You can also reverse the sense of what inside/outside is by setting the Inside\-Out instance variable. (The cutting algorithm proceeds by computing an implicit function value or using the input scalar data for each point in the dataset. This is compared to the scalar value to determine inside/outside.)

This filter can be configured to compute a second output. The second output is the portion of the volume that is clipped away. Set the Generate\-Clipped\-Data boolean on if you wish to access this output data.

The filter will produce an unstructured grid of entirely tetrahedra or a mixed grid of tetrahedra and other 3\-D cell types (e.\-g., wedges). Control this behavior by setting the Mixed3\-D\-Cell\-Generation. By default the Mixed3\-D\-Cell\-Generation is on and a combination of cell types will be produced. Note that producing mixed cell types is a faster than producing only tetrahedra.

To create an instance of class vtk\-Clip\-Volume, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkClipVolume
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Clip\-Volume has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Clip\-Volume class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Clip\-Volume = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Clip\-Volume = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Value (double )} -\/ Set the clipping value of the implicit function (if clipping with implicit function) or scalar value (if clipping with scalars). The default value is 0.\-0.  
\item {\ttfamily double = obj.\-Get\-Value ()} -\/ Set the clipping value of the implicit function (if clipping with implicit function) or scalar value (if clipping with scalars). The default value is 0.\-0.  
\item {\ttfamily obj.\-Set\-Inside\-Out (int )} -\/ Set/\-Get the Inside\-Out flag. When off, a vertex is considered inside the implicit function if its value is greater than the Value ivar. When Inside\-Outside is turned on, a vertex is considered inside the implicit function if its implicit function value is less than or equal to the Value ivar. Inside\-Out is off by default.  
\item {\ttfamily int = obj.\-Get\-Inside\-Out ()} -\/ Set/\-Get the Inside\-Out flag. When off, a vertex is considered inside the implicit function if its value is greater than the Value ivar. When Inside\-Outside is turned on, a vertex is considered inside the implicit function if its implicit function value is less than or equal to the Value ivar. Inside\-Out is off by default.  
\item {\ttfamily obj.\-Inside\-Out\-On ()} -\/ Set/\-Get the Inside\-Out flag. When off, a vertex is considered inside the implicit function if its value is greater than the Value ivar. When Inside\-Outside is turned on, a vertex is considered inside the implicit function if its implicit function value is less than or equal to the Value ivar. Inside\-Out is off by default.  
\item {\ttfamily obj.\-Inside\-Out\-Off ()} -\/ Set/\-Get the Inside\-Out flag. When off, a vertex is considered inside the implicit function if its value is greater than the Value ivar. When Inside\-Outside is turned on, a vertex is considered inside the implicit function if its implicit function value is less than or equal to the Value ivar. Inside\-Out is off by default.  
\item {\ttfamily obj.\-Set\-Clip\-Function (vtk\-Implicit\-Function )}  
\item {\ttfamily vtk\-Implicit\-Function = obj.\-Get\-Clip\-Function ()}  
\item {\ttfamily obj.\-Set\-Generate\-Clip\-Scalars (int )} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data. If you enable this flag but do not provide an implicit function an error will be reported.  
\item {\ttfamily int = obj.\-Get\-Generate\-Clip\-Scalars ()} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data. If you enable this flag but do not provide an implicit function an error will be reported.  
\item {\ttfamily obj.\-Generate\-Clip\-Scalars\-On ()} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data. If you enable this flag but do not provide an implicit function an error will be reported.  
\item {\ttfamily obj.\-Generate\-Clip\-Scalars\-Off ()} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data. If you enable this flag but do not provide an implicit function an error will be reported.  
\item {\ttfamily obj.\-Set\-Generate\-Clipped\-Output (int )} -\/ Control whether a second output is generated. The second output contains the unstructured grid that's been clipped away.  
\item {\ttfamily int = obj.\-Get\-Generate\-Clipped\-Output ()} -\/ Control whether a second output is generated. The second output contains the unstructured grid that's been clipped away.  
\item {\ttfamily obj.\-Generate\-Clipped\-Output\-On ()} -\/ Control whether a second output is generated. The second output contains the unstructured grid that's been clipped away.  
\item {\ttfamily obj.\-Generate\-Clipped\-Output\-Off ()} -\/ Control whether a second output is generated. The second output contains the unstructured grid that's been clipped away.  
\item {\ttfamily vtk\-Unstructured\-Grid = obj.\-Get\-Clipped\-Output ()} -\/ Return the clipped output.  
\item {\ttfamily obj.\-Set\-Mixed3\-D\-Cell\-Generation (int )} -\/ Control whether the filter produces a mix of 3\-D cell types on output, or whether the output cells are all tetrahedra. By default, a mixed set of cells (e.\-g., tetrahedra and wedges) is produced. (Note\-: mixed type generation is faster and less overall data is generated.)  
\item {\ttfamily int = obj.\-Get\-Mixed3\-D\-Cell\-Generation ()} -\/ Control whether the filter produces a mix of 3\-D cell types on output, or whether the output cells are all tetrahedra. By default, a mixed set of cells (e.\-g., tetrahedra and wedges) is produced. (Note\-: mixed type generation is faster and less overall data is generated.)  
\item {\ttfamily obj.\-Mixed3\-D\-Cell\-Generation\-On ()} -\/ Control whether the filter produces a mix of 3\-D cell types on output, or whether the output cells are all tetrahedra. By default, a mixed set of cells (e.\-g., tetrahedra and wedges) is produced. (Note\-: mixed type generation is faster and less overall data is generated.)  
\item {\ttfamily obj.\-Mixed3\-D\-Cell\-Generation\-Off ()} -\/ Control whether the filter produces a mix of 3\-D cell types on output, or whether the output cells are all tetrahedra. By default, a mixed set of cells (e.\-g., tetrahedra and wedges) is produced. (Note\-: mixed type generation is faster and less overall data is generated.)  
\item {\ttfamily obj.\-Set\-Merge\-Tolerance (double )} -\/ Set the tolerance for merging clip intersection points that are near the corners of voxels. This tolerance is used to prevent the generation of degenerate tetrahedra.  
\item {\ttfamily double = obj.\-Get\-Merge\-Tolerance\-Min\-Value ()} -\/ Set the tolerance for merging clip intersection points that are near the corners of voxels. This tolerance is used to prevent the generation of degenerate tetrahedra.  
\item {\ttfamily double = obj.\-Get\-Merge\-Tolerance\-Max\-Value ()} -\/ Set the tolerance for merging clip intersection points that are near the corners of voxels. This tolerance is used to prevent the generation of degenerate tetrahedra.  
\item {\ttfamily double = obj.\-Get\-Merge\-Tolerance ()} -\/ Set the tolerance for merging clip intersection points that are near the corners of voxels. This tolerance is used to prevent the generation of degenerate tetrahedra.  
\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. The locator is used to merge coincident points.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return the mtime also considering the locator and clip function.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkcoincidentpoints}{}\section{vtk\-Coincident\-Points}\label{vtkgraphics_vtkcoincidentpoints}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class provides a collection of points that is organized such that each coordinate is stored with a set of point id's of points that are all coincident.

To create an instance of class vtk\-Coincident\-Points, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCoincidentPoints
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Coincident\-Points has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Coincident\-Points class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Coincident\-Points = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Coincident\-Points = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Point (vtk\-Id\-Type Id, double point\mbox{[}3\mbox{]})} -\/ Accumulates a set of Ids in a map where the point coordinate is the key. All Ids in a given map entry are thus coincident. 
\begin{DoxyParams}[1]{Parameters}
 & {\em Id} & -\/ a unique Id for the given {\itshape point} that will be stored in an vtk\-Id\-List. \\
\hline
\mbox{\tt in}  & {\em point} & -\/ the point coordinate that we will store in the map to test if any other points are coincident with it.  \\
\hline
\end{DoxyParams}

\item {\ttfamily vtk\-Id\-List = obj.\-Get\-Coincident\-Point\-Ids (double point\mbox{[}3\mbox{]})} -\/ Retrieve the list of point Ids that are coincident with the given {\itshape point}. 
\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em point} & -\/ the coordinate of coincident points we want to retrieve.  \\
\hline
\end{DoxyParams}

\item {\ttfamily vtk\-Id\-List = obj.\-Get\-Next\-Coincident\-Point\-Ids ()} -\/ Used to iterate the sets of coincident points within the map. Init\-Traversal must be called first or N\-U\-L\-L will always be returned.  
\item {\ttfamily obj.\-Init\-Traversal ()}  
\item {\ttfamily obj.\-Remove\-Non\-Coincident\-Points ()}  
\item {\ttfamily obj.\-Clear ()}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkcompositedatageometryfilter}{}\section{vtk\-Composite\-Data\-Geometry\-Filter}\label{vtkgraphics_vtkcompositedatageometryfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Composite\-Data\-Geometry\-Filter applies vtk\-Geometry\-Filter to all leaves in vtk\-Composite\-Data\-Set. Place this filter at the end of a pipeline before a polydata consumer such as a polydata mapper to extract geometry from all blocks and append them to one polydata object.

To create an instance of class vtk\-Composite\-Data\-Geometry\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCompositeDataGeometryFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Composite\-Data\-Geometry\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Composite\-Data\-Geometry\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Composite\-Data\-Geometry\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Composite\-Data\-Geometry\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkcompositedataprobefilter}{}\section{vtk\-Composite\-Data\-Probe\-Filter}\label{vtkgraphics_vtkcompositedataprobefilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Composite\-Data\-Probe\-Filter supports probing into multi-\/group datasets. It sequentially probes through each concrete dataset within the composite probing at only those locations at which there were no hits when probing earlier datasets. For Hierarchical datasets, this traversal through leaf datasets is done in reverse order of levels i.\-e. highest level first.

When dealing with composite datasets, partial arrays are common i.\-e. data-\/arrays that are not available in all of the blocks. By default, this filter only passes those point and cell data-\/arrays that are available in all the blocks i.\-e. partial array are removed. When Pass\-Partial\-Arrays is turned on, this behavior is changed to take a union of all arrays present thus partial arrays are passed as well. However, for composite dataset input, this filter still produces a non-\/composite output. For all those locations in a block of where a particular data array is missing, this filter uses vtk\-Math\-::\-Nan() for double and float arrays, while 0 for all other types of arrays i.\-e int, char etc.

To create an instance of class vtk\-Composite\-Data\-Probe\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCompositeDataProbeFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Composite\-Data\-Probe\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Composite\-Data\-Probe\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Composite\-Data\-Probe\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Composite\-Data\-Probe\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Pass\-Partial\-Arrays (bool )} -\/ When dealing with composite datasets, partial arrays are common i.\-e. data-\/arrays that are not available in all of the blocks. By default, this filter only passes those point and cell data-\/arrays that are available in all the blocks i.\-e. partial array are removed. When Pass\-Partial\-Arrays is turned on, this behavior is changed to take a union of all arrays present thus partial arrays are passed as well. However, for composite dataset input, this filter still produces a non-\/composite output. For all those locations in a block of where a particular data array is missing, this filter uses vtk\-Math\-::\-Nan() for double and float arrays, while 0 for all other types of arrays i.\-e int, char etc.  
\item {\ttfamily bool = obj.\-Get\-Pass\-Partial\-Arrays ()} -\/ When dealing with composite datasets, partial arrays are common i.\-e. data-\/arrays that are not available in all of the blocks. By default, this filter only passes those point and cell data-\/arrays that are available in all the blocks i.\-e. partial array are removed. When Pass\-Partial\-Arrays is turned on, this behavior is changed to take a union of all arrays present thus partial arrays are passed as well. However, for composite dataset input, this filter still produces a non-\/composite output. For all those locations in a block of where a particular data array is missing, this filter uses vtk\-Math\-::\-Nan() for double and float arrays, while 0 for all other types of arrays i.\-e int, char etc.  
\item {\ttfamily obj.\-Pass\-Partial\-Arrays\-On ()} -\/ When dealing with composite datasets, partial arrays are common i.\-e. data-\/arrays that are not available in all of the blocks. By default, this filter only passes those point and cell data-\/arrays that are available in all the blocks i.\-e. partial array are removed. When Pass\-Partial\-Arrays is turned on, this behavior is changed to take a union of all arrays present thus partial arrays are passed as well. However, for composite dataset input, this filter still produces a non-\/composite output. For all those locations in a block of where a particular data array is missing, this filter uses vtk\-Math\-::\-Nan() for double and float arrays, while 0 for all other types of arrays i.\-e int, char etc.  
\item {\ttfamily obj.\-Pass\-Partial\-Arrays\-Off ()} -\/ When dealing with composite datasets, partial arrays are common i.\-e. data-\/arrays that are not available in all of the blocks. By default, this filter only passes those point and cell data-\/arrays that are available in all the blocks i.\-e. partial array are removed. When Pass\-Partial\-Arrays is turned on, this behavior is changed to take a union of all arrays present thus partial arrays are passed as well. However, for composite dataset input, this filter still produces a non-\/composite output. For all those locations in a block of where a particular data array is missing, this filter uses vtk\-Math\-::\-Nan() for double and float arrays, while 0 for all other types of arrays i.\-e int, char etc.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkconesource}{}\section{vtk\-Cone\-Source}\label{vtkgraphics_vtkconesource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Cone\-Source creates a cone centered at a specified point and pointing in a specified direction. (By default, the center is the origin and the direction is the x-\/axis.) Depending upon the resolution of this object, different representations are created. If resolution=0 a line is created; if resolution=1, a single triangle is created; if resolution=2, two crossed triangles are created. For resolution $>$ 2, a 3\-D cone (with resolution number of sides) is created. It also is possible to control whether the bottom of the cone is capped with a (resolution-\/sided) polygon, and to specify the height and radius of the cone.

To create an instance of class vtk\-Cone\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkConeSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Cone\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Cone\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Cone\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Cone\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Height (double )} -\/ Set the height of the cone. This is the height along the cone in its specified direction.  
\item {\ttfamily double = obj.\-Get\-Height\-Min\-Value ()} -\/ Set the height of the cone. This is the height along the cone in its specified direction.  
\item {\ttfamily double = obj.\-Get\-Height\-Max\-Value ()} -\/ Set the height of the cone. This is the height along the cone in its specified direction.  
\item {\ttfamily double = obj.\-Get\-Height ()} -\/ Set the height of the cone. This is the height along the cone in its specified direction.  
\item {\ttfamily obj.\-Set\-Radius (double )} -\/ Set the base radius of the cone.  
\item {\ttfamily double = obj.\-Get\-Radius\-Min\-Value ()} -\/ Set the base radius of the cone.  
\item {\ttfamily double = obj.\-Get\-Radius\-Max\-Value ()} -\/ Set the base radius of the cone.  
\item {\ttfamily double = obj.\-Get\-Radius ()} -\/ Set the base radius of the cone.  
\item {\ttfamily obj.\-Set\-Resolution (int )} -\/ Set the number of facets used to represent the cone.  
\item {\ttfamily int = obj.\-Get\-Resolution\-Min\-Value ()} -\/ Set the number of facets used to represent the cone.  
\item {\ttfamily int = obj.\-Get\-Resolution\-Max\-Value ()} -\/ Set the number of facets used to represent the cone.  
\item {\ttfamily int = obj.\-Get\-Resolution ()} -\/ Set the number of facets used to represent the cone.  
\item {\ttfamily obj.\-Set\-Center (double , double , double )} -\/ Set the center of the cone. It is located at the middle of the axis of the cone. Warning\-: this is not the center of the base of the cone! The default is 0,0,0.  
\item {\ttfamily obj.\-Set\-Center (double a\mbox{[}3\mbox{]})} -\/ Set the center of the cone. It is located at the middle of the axis of the cone. Warning\-: this is not the center of the base of the cone! The default is 0,0,0.  
\item {\ttfamily double = obj. Get\-Center ()} -\/ Set the center of the cone. It is located at the middle of the axis of the cone. Warning\-: this is not the center of the base of the cone! The default is 0,0,0.  
\item {\ttfamily obj.\-Set\-Direction (double , double , double )} -\/ Set the orientation vector of the cone. The vector does not have to be normalized. The direction goes from the center of the base toward the apex. The default is (1,0,0).  
\item {\ttfamily obj.\-Set\-Direction (double a\mbox{[}3\mbox{]})} -\/ Set the orientation vector of the cone. The vector does not have to be normalized. The direction goes from the center of the base toward the apex. The default is (1,0,0).  
\item {\ttfamily double = obj. Get\-Direction ()} -\/ Set the orientation vector of the cone. The vector does not have to be normalized. The direction goes from the center of the base toward the apex. The default is (1,0,0).  
\item {\ttfamily obj.\-Set\-Angle (double angle)} -\/ Set the angle of the cone. This is the angle between the axis of the cone and a generatrix. Warning\-: this is not the aperture! The aperture is twice this angle. As a side effect, the angle plus height sets the base radius of the cone. Angle is expressed in degrees.  
\item {\ttfamily double = obj.\-Get\-Angle ()} -\/ Set the angle of the cone. This is the angle between the axis of the cone and a generatrix. Warning\-: this is not the aperture! The aperture is twice this angle. As a side effect, the angle plus height sets the base radius of the cone. Angle is expressed in degrees.  
\item {\ttfamily obj.\-Set\-Capping (int )} -\/ Turn on/off whether to cap the base of the cone with a polygon.  
\item {\ttfamily int = obj.\-Get\-Capping ()} -\/ Turn on/off whether to cap the base of the cone with a polygon.  
\item {\ttfamily obj.\-Capping\-On ()} -\/ Turn on/off whether to cap the base of the cone with a polygon.  
\item {\ttfamily obj.\-Capping\-Off ()} -\/ Turn on/off whether to cap the base of the cone with a polygon.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkconnectivityfilter}{}\section{vtk\-Connectivity\-Filter}\label{vtkgraphics_vtkconnectivityfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Connectivity\-Filter is a filter that extracts cells that share common points and/or meet other connectivity criterion. (Cells that share vertices and meet other connectivity criterion such as scalar range are known as a region.) The filter works in one of six ways\-: 1) extract the largest connected region in the dataset; 2) extract specified region numbers; 3) extract all regions sharing specified point ids; 4) extract all regions sharing specified cell ids; 5) extract the region closest to the specified point; or 6) extract all regions (used to color the data by region).

vtk\-Connectivity\-Filter is generalized to handle any type of input dataset. It generates output data of type vtk\-Unstructured\-Grid. If you know that your input type is vtk\-Poly\-Data, you may wish to use vtk\-Poly\-Data\-Connectivity\-Filter.

The behavior of vtk\-Connectivity\-Filter can be modified by turning on the boolean ivar Scalar\-Connectivity. If this flag is on, the connectivity algorithm is modified so that cells are considered connected only if 1) they are geometrically connected (share a point) and 2) the scalar values of one of the cell's points falls in the scalar range specified. This use of Scalar\-Connectivity is particularly useful for volume datasets\-: it can be used as a simple \char`\"{}connected segmentation\char`\"{} algorithm. For example, by using a seed voxel (i.\-e., cell) on a known anatomical structure, connectivity will pull out all voxels \char`\"{}containing\char`\"{} the anatomical structure. These voxels can then be contoured or processed by other visualization filters.

To create an instance of class vtk\-Connectivity\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkConnectivityFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Connectivity\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Connectivity\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Connectivity\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Connectivity\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Scalar\-Connectivity (int )} -\/ Turn on/off connectivity based on scalar value. If on, cells are connected only if they share points A\-N\-D one of the cells scalar values falls in the scalar range specified.  
\item {\ttfamily int = obj.\-Get\-Scalar\-Connectivity ()} -\/ Turn on/off connectivity based on scalar value. If on, cells are connected only if they share points A\-N\-D one of the cells scalar values falls in the scalar range specified.  
\item {\ttfamily obj.\-Scalar\-Connectivity\-On ()} -\/ Turn on/off connectivity based on scalar value. If on, cells are connected only if they share points A\-N\-D one of the cells scalar values falls in the scalar range specified.  
\item {\ttfamily obj.\-Scalar\-Connectivity\-Off ()} -\/ Turn on/off connectivity based on scalar value. If on, cells are connected only if they share points A\-N\-D one of the cells scalar values falls in the scalar range specified.  
\item {\ttfamily obj.\-Set\-Scalar\-Range (double , double )} -\/ Set the scalar range to use to extract cells based on scalar connectivity.  
\item {\ttfamily obj.\-Set\-Scalar\-Range (double a\mbox{[}2\mbox{]})} -\/ Set the scalar range to use to extract cells based on scalar connectivity.  
\item {\ttfamily double = obj. Get\-Scalar\-Range ()} -\/ Set the scalar range to use to extract cells based on scalar connectivity.  
\item {\ttfamily obj.\-Set\-Extraction\-Mode (int )} -\/ Control the extraction of connected surfaces.  
\item {\ttfamily int = obj.\-Get\-Extraction\-Mode\-Min\-Value ()} -\/ Control the extraction of connected surfaces.  
\item {\ttfamily int = obj.\-Get\-Extraction\-Mode\-Max\-Value ()} -\/ Control the extraction of connected surfaces.  
\item {\ttfamily int = obj.\-Get\-Extraction\-Mode ()} -\/ Control the extraction of connected surfaces.  
\item {\ttfamily obj.\-Set\-Extraction\-Mode\-To\-Point\-Seeded\-Regions ()} -\/ Control the extraction of connected surfaces.  
\item {\ttfamily obj.\-Set\-Extraction\-Mode\-To\-Cell\-Seeded\-Regions ()} -\/ Control the extraction of connected surfaces.  
\item {\ttfamily obj.\-Set\-Extraction\-Mode\-To\-Largest\-Region ()} -\/ Control the extraction of connected surfaces.  
\item {\ttfamily obj.\-Set\-Extraction\-Mode\-To\-Specified\-Regions ()} -\/ Control the extraction of connected surfaces.  
\item {\ttfamily obj.\-Set\-Extraction\-Mode\-To\-Closest\-Point\-Region ()} -\/ Control the extraction of connected surfaces.  
\item {\ttfamily obj.\-Set\-Extraction\-Mode\-To\-All\-Regions ()} -\/ Control the extraction of connected surfaces.  
\item {\ttfamily string = obj.\-Get\-Extraction\-Mode\-As\-String ()} -\/ Control the extraction of connected surfaces.  
\item {\ttfamily obj.\-Initialize\-Seed\-List ()} -\/ Initialize list of point ids/cell ids used to seed regions.  
\item {\ttfamily obj.\-Add\-Seed (vtk\-Id\-Type id)} -\/ Add a seed id (point or cell id). Note\-: ids are 0-\/offset.  
\item {\ttfamily obj.\-Delete\-Seed (vtk\-Id\-Type id)} -\/ Delete a seed id (point or cell id). Note\-: ids are 0-\/offset.  
\item {\ttfamily obj.\-Initialize\-Specified\-Region\-List ()} -\/ Initialize list of region ids to extract.  
\item {\ttfamily obj.\-Add\-Specified\-Region (int id)} -\/ Add a region id to extract. Note\-: ids are 0-\/offset.  
\item {\ttfamily obj.\-Delete\-Specified\-Region (int id)} -\/ Delete a region id to extract. Note\-: ids are 0-\/offset.  
\item {\ttfamily obj.\-Set\-Closest\-Point (double , double , double )} -\/ Use to specify x-\/y-\/z point coordinates when extracting the region closest to a specified point.  
\item {\ttfamily obj.\-Set\-Closest\-Point (double a\mbox{[}3\mbox{]})} -\/ Use to specify x-\/y-\/z point coordinates when extracting the region closest to a specified point.  
\item {\ttfamily double = obj. Get\-Closest\-Point ()} -\/ Use to specify x-\/y-\/z point coordinates when extracting the region closest to a specified point.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Extracted\-Regions ()} -\/ Obtain the number of connected regions.  
\item {\ttfamily obj.\-Set\-Color\-Regions (int )} -\/ Turn on/off the coloring of connected regions.  
\item {\ttfamily int = obj.\-Get\-Color\-Regions ()} -\/ Turn on/off the coloring of connected regions.  
\item {\ttfamily obj.\-Color\-Regions\-On ()} -\/ Turn on/off the coloring of connected regions.  
\item {\ttfamily obj.\-Color\-Regions\-Off ()} -\/ Turn on/off the coloring of connected regions.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkcontourfilter}{}\section{vtk\-Contour\-Filter}\label{vtkgraphics_vtkcontourfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Contour\-Filter is a filter that takes as input any dataset and generates on output isosurfaces and/or isolines. The exact form of the output depends upon the dimensionality of the input data. Data consisting of 3\-D cells will generate isosurfaces, data consisting of 2\-D cells will generate isolines, and data with 1\-D or 0\-D cells will generate isopoints. Combinations of output type are possible if the input dimension is mixed.

To use this filter you must specify one or more contour values. You can either use the method Set\-Value() to specify each contour value, or use Generate\-Values() to generate a series of evenly spaced contours. It is also possible to accelerate the operation of this filter (at the cost of extra memory) by using a vtk\-Scalar\-Tree. A scalar tree is used to quickly locate cells that contain a contour surface. This is especially effective if multiple contours are being extracted. If you want to use a scalar tree, invoke the method Use\-Scalar\-Tree\-On().

To create an instance of class vtk\-Contour\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkContourFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Contour\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Contour\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Contour\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Contour\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Value (int i, double value)} -\/ Methods to set / get contour values.  
\item {\ttfamily double = obj.\-Get\-Value (int i)} -\/ Methods to set / get contour values.  
\item {\ttfamily obj.\-Get\-Values (double contour\-Values)} -\/ Methods to set / get contour values.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Contours (int number)} -\/ Methods to set / get contour values.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Contours ()} -\/ Methods to set / get contour values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\mbox{[}2\mbox{]})} -\/ Methods to set / get contour values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\-Start, double range\-End)} -\/ Methods to set / get contour values.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Modified Get\-M\-Time Because we delegate to vtk\-Contour\-Values  
\item {\ttfamily obj.\-Set\-Compute\-Normals (int )} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily int = obj.\-Get\-Compute\-Normals ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Normals\-On ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Normals\-Off ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Set\-Compute\-Gradients (int )} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily int = obj.\-Get\-Compute\-Gradients ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Gradients\-On ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Gradients\-Off ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Set\-Compute\-Scalars (int )} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily int = obj.\-Get\-Compute\-Scalars ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Compute\-Scalars\-On ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Compute\-Scalars\-Off ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Set\-Use\-Scalar\-Tree (int )} -\/ Enable the use of a scalar tree to accelerate contour extraction.  
\item {\ttfamily int = obj.\-Get\-Use\-Scalar\-Tree ()} -\/ Enable the use of a scalar tree to accelerate contour extraction.  
\item {\ttfamily obj.\-Use\-Scalar\-Tree\-On ()} -\/ Enable the use of a scalar tree to accelerate contour extraction.  
\item {\ttfamily obj.\-Use\-Scalar\-Tree\-Off ()} -\/ Enable the use of a scalar tree to accelerate contour extraction.  
\item {\ttfamily obj.\-Set\-Scalar\-Tree (vtk\-Scalar\-Tree )} -\/ Enable the use of a scalar tree to accelerate contour extraction.  
\item {\ttfamily vtk\-Scalar\-Tree = obj.\-Get\-Scalar\-Tree ()} -\/ Enable the use of a scalar tree to accelerate contour extraction.  
\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. The locator is used to merge coincident points.  
\item {\ttfamily obj.\-Set\-Array\-Component (int )} -\/ Set/get which component of the scalar array to contour on; defaults to 0. Currently this feature only works if the input is a vtk\-Image\-Data.  
\item {\ttfamily int = obj.\-Get\-Array\-Component ()} -\/ Set/get which component of the scalar array to contour on; defaults to 0. Currently this feature only works if the input is a vtk\-Image\-Data.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkcontourgrid}{}\section{vtk\-Contour\-Grid}\label{vtkgraphics_vtkcontourgrid}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Contour\-Grid is a filter that takes as input datasets of type vtk\-Unstructured\-Grid and generates on output isosurfaces and/or isolines. The exact form of the output depends upon the dimensionality of the input data. Data consisting of 3\-D cells will generate isosurfaces, data consisting of 2\-D cells will generate isolines, and data with 1\-D or 0\-D cells will generate isopoints. Combinations of output type are possible if the input dimension is mixed.

To use this filter you must specify one or more contour values. You can either use the method Set\-Value() to specify each contour value, or use Generate\-Values() to generate a series of evenly spaced contours. It is also possible to accelerate the operation of this filter (at the cost of extra memory) by using a vtk\-Scalar\-Tree. A scalar tree is used to quickly locate cells that contain a contour surface. This is especially effective if multiple contours are being extracted. If you want to use a scalar tree, invoke the method Use\-Scalar\-Tree\-On().

To create an instance of class vtk\-Contour\-Grid, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkContourGrid
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Contour\-Grid has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Contour\-Grid class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Contour\-Grid = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Contour\-Grid = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Value (int i, double value)} -\/ Methods to set / get contour values.  
\item {\ttfamily double = obj.\-Get\-Value (int i)} -\/ Methods to set / get contour values.  
\item {\ttfamily obj.\-Get\-Values (double contour\-Values)} -\/ Methods to set / get contour values.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Contours (int number)} -\/ Methods to set / get contour values.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Contours ()} -\/ Methods to set / get contour values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\mbox{[}2\mbox{]})} -\/ Methods to set / get contour values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\-Start, double range\-End)} -\/ Methods to set / get contour values.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Modified Get\-M\-Time Because we delegate to vtk\-Contour\-Values  
\item {\ttfamily obj.\-Set\-Compute\-Normals (int )} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily int = obj.\-Get\-Compute\-Normals ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Normals\-On ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Normals\-Off ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Set\-Compute\-Gradients (int )} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily int = obj.\-Get\-Compute\-Gradients ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Gradients\-On ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Gradients\-Off ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Set\-Compute\-Scalars (int )} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily int = obj.\-Get\-Compute\-Scalars ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Compute\-Scalars\-On ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Compute\-Scalars\-Off ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Set\-Use\-Scalar\-Tree (int )} -\/ Enable the use of a scalar tree to accelerate contour extraction.  
\item {\ttfamily int = obj.\-Get\-Use\-Scalar\-Tree ()} -\/ Enable the use of a scalar tree to accelerate contour extraction.  
\item {\ttfamily obj.\-Use\-Scalar\-Tree\-On ()} -\/ Enable the use of a scalar tree to accelerate contour extraction.  
\item {\ttfamily obj.\-Use\-Scalar\-Tree\-Off ()} -\/ Enable the use of a scalar tree to accelerate contour extraction.  
\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. The locator is used to merge coincident points.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkconvertselection}{}\section{vtk\-Convert\-Selection}\label{vtkgraphics_vtkconvertselection}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Convert\-Selection converts an input selection from one type to another in the context of a data object being selected. The first input is the selection, while the second input is the data object that the selection relates to.

To create an instance of class vtk\-Convert\-Selection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkConvertSelection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Convert\-Selection has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Convert\-Selection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Convert\-Selection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Convert\-Selection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Data\-Object\-Connection (vtk\-Algorithm\-Output in)} -\/ A convenience method for setting the second input (i.\-e. the data object).  
\item {\ttfamily obj.\-Set\-Input\-Field\-Type (int )} -\/ The input field type. If this is set to a number other than -\/1, ignores the input selection field type and instead assumes that all selection nodes have the field type specified. This should be one of the constants defined in vtk\-Selection\-Node.\-h. Default is -\/1.  
\item {\ttfamily int = obj.\-Get\-Input\-Field\-Type ()} -\/ The input field type. If this is set to a number other than -\/1, ignores the input selection field type and instead assumes that all selection nodes have the field type specified. This should be one of the constants defined in vtk\-Selection\-Node.\-h. Default is -\/1.  
\item {\ttfamily obj.\-Set\-Output\-Type (int )} -\/ The output selection content type. This should be one of the constants defined in vtk\-Selection\-Node.\-h.  
\item {\ttfamily int = obj.\-Get\-Output\-Type ()} -\/ The output selection content type. This should be one of the constants defined in vtk\-Selection\-Node.\-h.  
\item {\ttfamily obj.\-Set\-Array\-Name (string )} -\/ The output array name for value or threshold selections.  
\item {\ttfamily string = obj.\-Get\-Array\-Name ()} -\/ The output array name for value or threshold selections.  
\item {\ttfamily obj.\-Set\-Array\-Names (vtk\-String\-Array )} -\/ The output array names for value selection.  
\item {\ttfamily vtk\-String\-Array = obj.\-Get\-Array\-Names ()} -\/ The output array names for value selection.  
\item {\ttfamily obj.\-Add\-Array\-Name (string )} -\/ Convenience methods used by U\-I  
\item {\ttfamily obj.\-Clear\-Array\-Names ()} -\/ Convenience methods used by U\-I  
\item {\ttfamily obj.\-Set\-Match\-Any\-Values (bool )} -\/ When on, creates a separate selection node for each array. Defaults to O\-F\-F.  
\item {\ttfamily bool = obj.\-Get\-Match\-Any\-Values ()} -\/ When on, creates a separate selection node for each array. Defaults to O\-F\-F.  
\item {\ttfamily obj.\-Match\-Any\-Values\-On ()} -\/ When on, creates a separate selection node for each array. Defaults to O\-F\-F.  
\item {\ttfamily obj.\-Match\-Any\-Values\-Off ()} -\/ When on, creates a separate selection node for each array. Defaults to O\-F\-F.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkcubesource}{}\section{vtk\-Cube\-Source}\label{vtkgraphics_vtkcubesource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Cube\-Source creates a cube centered at origin. The cube is represented with four-\/sided polygons. It is possible to specify the length, width, and height of the cube independently.

To create an instance of class vtk\-Cube\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCubeSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Cube\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Cube\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Cube\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Cube\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-X\-Length (double )} -\/ Set the length of the cube in the x-\/direction.  
\item {\ttfamily double = obj.\-Get\-X\-Length\-Min\-Value ()} -\/ Set the length of the cube in the x-\/direction.  
\item {\ttfamily double = obj.\-Get\-X\-Length\-Max\-Value ()} -\/ Set the length of the cube in the x-\/direction.  
\item {\ttfamily double = obj.\-Get\-X\-Length ()} -\/ Set the length of the cube in the x-\/direction.  
\item {\ttfamily obj.\-Set\-Y\-Length (double )} -\/ Set the length of the cube in the y-\/direction.  
\item {\ttfamily double = obj.\-Get\-Y\-Length\-Min\-Value ()} -\/ Set the length of the cube in the y-\/direction.  
\item {\ttfamily double = obj.\-Get\-Y\-Length\-Max\-Value ()} -\/ Set the length of the cube in the y-\/direction.  
\item {\ttfamily double = obj.\-Get\-Y\-Length ()} -\/ Set the length of the cube in the y-\/direction.  
\item {\ttfamily obj.\-Set\-Z\-Length (double )} -\/ Set the length of the cube in the z-\/direction.  
\item {\ttfamily double = obj.\-Get\-Z\-Length\-Min\-Value ()} -\/ Set the length of the cube in the z-\/direction.  
\item {\ttfamily double = obj.\-Get\-Z\-Length\-Max\-Value ()} -\/ Set the length of the cube in the z-\/direction.  
\item {\ttfamily double = obj.\-Get\-Z\-Length ()} -\/ Set the length of the cube in the z-\/direction.  
\item {\ttfamily obj.\-Set\-Center (double , double , double )} -\/ Set the center of the cube.  
\item {\ttfamily obj.\-Set\-Center (double a\mbox{[}3\mbox{]})} -\/ Set the center of the cube.  
\item {\ttfamily double = obj. Get\-Center ()} -\/ Set the center of the cube.  
\item {\ttfamily obj.\-Set\-Bounds (double x\-Min, double x\-Max, double y\-Min, double y\-Max, double z\-Min, double z\-Max)} -\/ Convenience method allows creation of cube by specifying bounding box.  
\item {\ttfamily obj.\-Set\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Convenience method allows creation of cube by specifying bounding box.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkcursor2d}{}\section{vtk\-Cursor2\-D}\label{vtkgraphics_vtkcursor2d}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Cursor2\-D is a class that generates a 2\-D cursor representation. The cursor consists of two intersection axes lines that meet at the cursor focus. Several optional features are available as well. An optional 2\-D bounding box may be enabled. An inner radius, centered at the focal point, can be set that erases the intersecting lines (e.\-g., it leaves a clear area under the focal point so you can see what you are selecting). And finally, an optional point can be enabled located at the focal point. All of these features can be turned on and off independently.

To create an instance of class vtk\-Cursor2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCursor2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Cursor2\-D has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Cursor2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Cursor2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Cursor2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Model\-Bounds (double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)} -\/ Set / get the bounding box of the 2\-D cursor. This defines the outline of the cursor, and where the focal point should lie.  
\item {\ttfamily obj.\-Set\-Model\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Set / get the bounding box of the 2\-D cursor. This defines the outline of the cursor, and where the focal point should lie.  
\item {\ttfamily double = obj. Get\-Model\-Bounds ()} -\/ Set / get the bounding box of the 2\-D cursor. This defines the outline of the cursor, and where the focal point should lie.  
\item {\ttfamily obj.\-Set\-Focal\-Point (double x\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of cursor focus. If translation mode is on, then the entire cursor (including bounding box, cursor, and shadows) is translated. Otherwise, the focal point will either be clamped to the bounding box, or wrapped, if Wrap is on. (Note\-: this behavior requires that the bounding box is set prior to the focal point.) Note that the method takes a 3\-D point but ignores the z-\/coordinate value.  
\item {\ttfamily obj.\-Set\-Focal\-Point (double x, double y, double z)} -\/ Set/\-Get the position of cursor focus. If translation mode is on, then the entire cursor (including bounding box, cursor, and shadows) is translated. Otherwise, the focal point will either be clamped to the bounding box, or wrapped, if Wrap is on. (Note\-: this behavior requires that the bounding box is set prior to the focal point.) Note that the method takes a 3\-D point but ignores the z-\/coordinate value.  
\item {\ttfamily double = obj. Get\-Focal\-Point ()} -\/ Set/\-Get the position of cursor focus. If translation mode is on, then the entire cursor (including bounding box, cursor, and shadows) is translated. Otherwise, the focal point will either be clamped to the bounding box, or wrapped, if Wrap is on. (Note\-: this behavior requires that the bounding box is set prior to the focal point.) Note that the method takes a 3\-D point but ignores the z-\/coordinate value.  
\item {\ttfamily obj.\-Set\-Outline (int )} -\/ Turn on/off the wireframe bounding box.  
\item {\ttfamily int = obj.\-Get\-Outline ()} -\/ Turn on/off the wireframe bounding box.  
\item {\ttfamily obj.\-Outline\-On ()} -\/ Turn on/off the wireframe bounding box.  
\item {\ttfamily obj.\-Outline\-Off ()} -\/ Turn on/off the wireframe bounding box.  
\item {\ttfamily obj.\-Set\-Axes (int )} -\/ Turn on/off the wireframe axes.  
\item {\ttfamily int = obj.\-Get\-Axes ()} -\/ Turn on/off the wireframe axes.  
\item {\ttfamily obj.\-Axes\-On ()} -\/ Turn on/off the wireframe axes.  
\item {\ttfamily obj.\-Axes\-Off ()} -\/ Turn on/off the wireframe axes.  
\item {\ttfamily obj.\-Set\-Radius (double )} -\/ Specify a radius for a circle. This erases the cursor lines around the focal point.  
\item {\ttfamily double = obj.\-Get\-Radius\-Min\-Value ()} -\/ Specify a radius for a circle. This erases the cursor lines around the focal point.  
\item {\ttfamily double = obj.\-Get\-Radius\-Max\-Value ()} -\/ Specify a radius for a circle. This erases the cursor lines around the focal point.  
\item {\ttfamily double = obj.\-Get\-Radius ()} -\/ Specify a radius for a circle. This erases the cursor lines around the focal point.  
\item {\ttfamily obj.\-Set\-Point (int )} -\/ Turn on/off the point located at the cursor focus.  
\item {\ttfamily int = obj.\-Get\-Point ()} -\/ Turn on/off the point located at the cursor focus.  
\item {\ttfamily obj.\-Point\-On ()} -\/ Turn on/off the point located at the cursor focus.  
\item {\ttfamily obj.\-Point\-Off ()} -\/ Turn on/off the point located at the cursor focus.  
\item {\ttfamily obj.\-Set\-Translation\-Mode (int )} -\/ Enable/disable the translation mode. If on, changes in cursor position cause the entire widget to translate along with the cursor. By default, translation mode is off.  
\item {\ttfamily int = obj.\-Get\-Translation\-Mode ()} -\/ Enable/disable the translation mode. If on, changes in cursor position cause the entire widget to translate along with the cursor. By default, translation mode is off.  
\item {\ttfamily obj.\-Translation\-Mode\-On ()} -\/ Enable/disable the translation mode. If on, changes in cursor position cause the entire widget to translate along with the cursor. By default, translation mode is off.  
\item {\ttfamily obj.\-Translation\-Mode\-Off ()} -\/ Enable/disable the translation mode. If on, changes in cursor position cause the entire widget to translate along with the cursor. By default, translation mode is off.  
\item {\ttfamily obj.\-Set\-Wrap (int )} -\/ Turn on/off cursor wrapping. If the cursor focus moves outside the specified bounds, the cursor will either be restrained against the nearest \char`\"{}wall\char`\"{} (Wrap=off), or it will wrap around (Wrap=on).  
\item {\ttfamily int = obj.\-Get\-Wrap ()} -\/ Turn on/off cursor wrapping. If the cursor focus moves outside the specified bounds, the cursor will either be restrained against the nearest \char`\"{}wall\char`\"{} (Wrap=off), or it will wrap around (Wrap=on).  
\item {\ttfamily obj.\-Wrap\-On ()} -\/ Turn on/off cursor wrapping. If the cursor focus moves outside the specified bounds, the cursor will either be restrained against the nearest \char`\"{}wall\char`\"{} (Wrap=off), or it will wrap around (Wrap=on).  
\item {\ttfamily obj.\-Wrap\-Off ()} -\/ Turn on/off cursor wrapping. If the cursor focus moves outside the specified bounds, the cursor will either be restrained against the nearest \char`\"{}wall\char`\"{} (Wrap=off), or it will wrap around (Wrap=on).  
\item {\ttfamily obj.\-All\-On ()} -\/ Turn every part of the cursor on or off.  
\item {\ttfamily obj.\-All\-Off ()} -\/ Turn every part of the cursor on or off.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkcursor3d}{}\section{vtk\-Cursor3\-D}\label{vtkgraphics_vtkcursor3d}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Cursor3\-D is an object that generates a 3\-D representation of a cursor. The cursor consists of a wireframe bounding box, three intersecting axes lines that meet at the cursor focus, and \char`\"{}shadows\char`\"{} or projections of the axes against the sides of the bounding box. Each of these components can be turned on/off.

This filter generates two output datasets. The first (Output) is just the geometric representation of the cursor. The second (Focus) is a single point at the focal point.

To create an instance of class vtk\-Cursor3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCursor3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Cursor3\-D has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Cursor3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Cursor3\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Cursor3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Model\-Bounds (double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)} -\/ Set / get the boundary of the 3\-D cursor.  
\item {\ttfamily obj.\-Set\-Model\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Set / get the boundary of the 3\-D cursor.  
\item {\ttfamily double = obj. Get\-Model\-Bounds ()} -\/ Set / get the boundary of the 3\-D cursor.  
\item {\ttfamily obj.\-Set\-Focal\-Point (double x\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of cursor focus. If translation mode is on, then the entire cursor (including bounding box, cursor, and shadows) is translated. Otherwise, the focal point will either be clamped to the bounding box, or wrapped, if Wrap is on. (Note\-: this behavior requires that the bounding box is set prior to the focal point.)  
\item {\ttfamily obj.\-Set\-Focal\-Point (double x, double y, double z)} -\/ Set/\-Get the position of cursor focus. If translation mode is on, then the entire cursor (including bounding box, cursor, and shadows) is translated. Otherwise, the focal point will either be clamped to the bounding box, or wrapped, if Wrap is on. (Note\-: this behavior requires that the bounding box is set prior to the focal point.)  
\item {\ttfamily double = obj. Get\-Focal\-Point ()} -\/ Set/\-Get the position of cursor focus. If translation mode is on, then the entire cursor (including bounding box, cursor, and shadows) is translated. Otherwise, the focal point will either be clamped to the bounding box, or wrapped, if Wrap is on. (Note\-: this behavior requires that the bounding box is set prior to the focal point.)  
\item {\ttfamily obj.\-Set\-Outline (int )} -\/ Turn on/off the wireframe bounding box.  
\item {\ttfamily int = obj.\-Get\-Outline ()} -\/ Turn on/off the wireframe bounding box.  
\item {\ttfamily obj.\-Outline\-On ()} -\/ Turn on/off the wireframe bounding box.  
\item {\ttfamily obj.\-Outline\-Off ()} -\/ Turn on/off the wireframe bounding box.  
\item {\ttfamily obj.\-Set\-Axes (int )} -\/ Turn on/off the wireframe axes.  
\item {\ttfamily int = obj.\-Get\-Axes ()} -\/ Turn on/off the wireframe axes.  
\item {\ttfamily obj.\-Axes\-On ()} -\/ Turn on/off the wireframe axes.  
\item {\ttfamily obj.\-Axes\-Off ()} -\/ Turn on/off the wireframe axes.  
\item {\ttfamily obj.\-Set\-X\-Shadows (int )} -\/ Turn on/off the wireframe x-\/shadows.  
\item {\ttfamily int = obj.\-Get\-X\-Shadows ()} -\/ Turn on/off the wireframe x-\/shadows.  
\item {\ttfamily obj.\-X\-Shadows\-On ()} -\/ Turn on/off the wireframe x-\/shadows.  
\item {\ttfamily obj.\-X\-Shadows\-Off ()} -\/ Turn on/off the wireframe x-\/shadows.  
\item {\ttfamily obj.\-Set\-Y\-Shadows (int )} -\/ Turn on/off the wireframe y-\/shadows.  
\item {\ttfamily int = obj.\-Get\-Y\-Shadows ()} -\/ Turn on/off the wireframe y-\/shadows.  
\item {\ttfamily obj.\-Y\-Shadows\-On ()} -\/ Turn on/off the wireframe y-\/shadows.  
\item {\ttfamily obj.\-Y\-Shadows\-Off ()} -\/ Turn on/off the wireframe y-\/shadows.  
\item {\ttfamily obj.\-Set\-Z\-Shadows (int )} -\/ Turn on/off the wireframe z-\/shadows.  
\item {\ttfamily int = obj.\-Get\-Z\-Shadows ()} -\/ Turn on/off the wireframe z-\/shadows.  
\item {\ttfamily obj.\-Z\-Shadows\-On ()} -\/ Turn on/off the wireframe z-\/shadows.  
\item {\ttfamily obj.\-Z\-Shadows\-Off ()} -\/ Turn on/off the wireframe z-\/shadows.  
\item {\ttfamily obj.\-Set\-Translation\-Mode (int )} -\/ Enable/disable the translation mode. If on, changes in cursor position cause the entire widget to translate along with the cursor. By default, translation mode is off.  
\item {\ttfamily int = obj.\-Get\-Translation\-Mode ()} -\/ Enable/disable the translation mode. If on, changes in cursor position cause the entire widget to translate along with the cursor. By default, translation mode is off.  
\item {\ttfamily obj.\-Translation\-Mode\-On ()} -\/ Enable/disable the translation mode. If on, changes in cursor position cause the entire widget to translate along with the cursor. By default, translation mode is off.  
\item {\ttfamily obj.\-Translation\-Mode\-Off ()} -\/ Enable/disable the translation mode. If on, changes in cursor position cause the entire widget to translate along with the cursor. By default, translation mode is off.  
\item {\ttfamily obj.\-Set\-Wrap (int )} -\/ Turn on/off cursor wrapping. If the cursor focus moves outside the specified bounds, the cursor will either be restrained against the nearest \char`\"{}wall\char`\"{} (Wrap=off), or it will wrap around (Wrap=on).  
\item {\ttfamily int = obj.\-Get\-Wrap ()} -\/ Turn on/off cursor wrapping. If the cursor focus moves outside the specified bounds, the cursor will either be restrained against the nearest \char`\"{}wall\char`\"{} (Wrap=off), or it will wrap around (Wrap=on).  
\item {\ttfamily obj.\-Wrap\-On ()} -\/ Turn on/off cursor wrapping. If the cursor focus moves outside the specified bounds, the cursor will either be restrained against the nearest \char`\"{}wall\char`\"{} (Wrap=off), or it will wrap around (Wrap=on).  
\item {\ttfamily obj.\-Wrap\-Off ()} -\/ Turn on/off cursor wrapping. If the cursor focus moves outside the specified bounds, the cursor will either be restrained against the nearest \char`\"{}wall\char`\"{} (Wrap=off), or it will wrap around (Wrap=on).  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Focus ()} -\/ Get the focus for this filter.  
\item {\ttfamily obj.\-All\-On ()} -\/ Turn every part of the 3\-D cursor on or off.  
\item {\ttfamily obj.\-All\-Off ()} -\/ Turn every part of the 3\-D cursor on or off.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkcurvatures}{}\section{vtk\-Curvatures}\label{vtkgraphics_vtkcurvatures}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Curvatures takes a polydata input and computes the curvature of the mesh at each point. Four possible methods of computation are available \-:

Gauss Curvature discrete Gauss curvature (K) computation, $K(vertex v) = 2*PI-\sum_{facet neighbs f of v} (angle_f at v)$ The contribution of every facet is for the moment weighted by $Area(facet)/3$ The units of Gaussian Curvature are $[1/m^2]$

Mean Curvature $H(vertex v) = average over edges neighbs e of H(e)$ $H(edge e) = length(e)*dihedral_angle(e)$ N\-B\-: dihedral\-\_\-angle is the O\-R\-I\-E\-N\-T\-E\-D angle between -\/\-P\-I and P\-I, this means that the surface is assumed to be orientable the computation creates the orientation The units of Mean Curvature are \mbox{[}1/m\mbox{]}

Maximum ( $k_max$) and Minimum ( $k_min$) Principal Curvatures $k_max = H + sqrt(H^2 - K)$ $k_min = H - sqrt(H^2 - K)$ Excepting spherical and planar surfaces which have equal principal curvatures, the curvature at a point on a surface varies with the direction one \char`\"{}sets off\char`\"{} from the point. For all directions, the curvature will pass through two extrema\-: a minimum ( $k_min$) and a maximum ( $k_max$) which occur at mutually orthogonal directions to each other.

N\-B. The sign of the Gauss curvature is a geometric ivariant, it should be +ve when the surface looks like a sphere, -\/ve when it looks like a saddle, however, the sign of the Mean curvature is not, it depends on the convention for normals -\/ This code assumes that normals point outwards (ie from the surface of a sphere outwards). If a given mesh produces curvatures of opposite senses then the flag Invert\-Mean\-Curvature can be set and the Curvature reported by the Mean calculation will be inverted.

.S\-E\-C\-T\-I\-O\-N Thanks Philip Batchelor \href{mailto:philipp.batchelor@kcl.ac.uk}{\tt philipp.\-batchelor@kcl.\-ac.\-uk} for creating and contributing the class and Andrew Maclean \href{mailto:a.maclean@acfr.usyd.edu.au}{\tt a.\-maclean@acfr.\-usyd.\-edu.\-au} for cleanups and fixes. Thanks also to Goodwin Lawlor for contributing patch to calculate principal curvatures

To create an instance of class vtk\-Curvatures, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCurvatures
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Curvatures has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Curvatures class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Curvatures = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Curvatures = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Curvature\-Type (int )} -\/ Set/\-Get Curvature type V\-T\-K\-\_\-\-C\-U\-R\-V\-A\-T\-U\-R\-E\-\_\-\-G\-A\-U\-S\-S\-: Gaussian curvature, stored as Data\-Array \char`\"{}\-Gauss\-\_\-\-Curvature\char`\"{} V\-T\-K\-\_\-\-C\-U\-R\-V\-A\-T\-U\-R\-E\-\_\-\-M\-E\-A\-N \-: Mean curvature, stored as Data\-Array \char`\"{}\-Mean\-\_\-\-Curvature\char`\"{}  
\item {\ttfamily int = obj.\-Get\-Curvature\-Type ()} -\/ Set/\-Get Curvature type V\-T\-K\-\_\-\-C\-U\-R\-V\-A\-T\-U\-R\-E\-\_\-\-G\-A\-U\-S\-S\-: Gaussian curvature, stored as Data\-Array \char`\"{}\-Gauss\-\_\-\-Curvature\char`\"{} V\-T\-K\-\_\-\-C\-U\-R\-V\-A\-T\-U\-R\-E\-\_\-\-M\-E\-A\-N \-: Mean curvature, stored as Data\-Array \char`\"{}\-Mean\-\_\-\-Curvature\char`\"{}  
\item {\ttfamily obj.\-Set\-Curvature\-Type\-To\-Gaussian ()} -\/ Set/\-Get Curvature type V\-T\-K\-\_\-\-C\-U\-R\-V\-A\-T\-U\-R\-E\-\_\-\-G\-A\-U\-S\-S\-: Gaussian curvature, stored as Data\-Array \char`\"{}\-Gauss\-\_\-\-Curvature\char`\"{} V\-T\-K\-\_\-\-C\-U\-R\-V\-A\-T\-U\-R\-E\-\_\-\-M\-E\-A\-N \-: Mean curvature, stored as Data\-Array \char`\"{}\-Mean\-\_\-\-Curvature\char`\"{}  
\item {\ttfamily obj.\-Set\-Curvature\-Type\-To\-Mean ()} -\/ Set/\-Get Curvature type V\-T\-K\-\_\-\-C\-U\-R\-V\-A\-T\-U\-R\-E\-\_\-\-G\-A\-U\-S\-S\-: Gaussian curvature, stored as Data\-Array \char`\"{}\-Gauss\-\_\-\-Curvature\char`\"{} V\-T\-K\-\_\-\-C\-U\-R\-V\-A\-T\-U\-R\-E\-\_\-\-M\-E\-A\-N \-: Mean curvature, stored as Data\-Array \char`\"{}\-Mean\-\_\-\-Curvature\char`\"{}  
\item {\ttfamily obj.\-Set\-Curvature\-Type\-To\-Maximum ()} -\/ Set/\-Get Curvature type V\-T\-K\-\_\-\-C\-U\-R\-V\-A\-T\-U\-R\-E\-\_\-\-G\-A\-U\-S\-S\-: Gaussian curvature, stored as Data\-Array \char`\"{}\-Gauss\-\_\-\-Curvature\char`\"{} V\-T\-K\-\_\-\-C\-U\-R\-V\-A\-T\-U\-R\-E\-\_\-\-M\-E\-A\-N \-: Mean curvature, stored as Data\-Array \char`\"{}\-Mean\-\_\-\-Curvature\char`\"{}  
\item {\ttfamily obj.\-Set\-Curvature\-Type\-To\-Minimum ()} -\/ Set/\-Get the flag which inverts the mean curvature calculation for meshes with inward pointing normals (default false)  
\item {\ttfamily obj.\-Set\-Invert\-Mean\-Curvature (int )} -\/ Set/\-Get the flag which inverts the mean curvature calculation for meshes with inward pointing normals (default false)  
\item {\ttfamily int = obj.\-Get\-Invert\-Mean\-Curvature ()} -\/ Set/\-Get the flag which inverts the mean curvature calculation for meshes with inward pointing normals (default false)  
\item {\ttfamily obj.\-Invert\-Mean\-Curvature\-On ()} -\/ Set/\-Get the flag which inverts the mean curvature calculation for meshes with inward pointing normals (default false)  
\item {\ttfamily obj.\-Invert\-Mean\-Curvature\-Off ()} -\/ Set/\-Get the flag which inverts the mean curvature calculation for meshes with inward pointing normals (default false)  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkcutter}{}\section{vtk\-Cutter}\label{vtkgraphics_vtkcutter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Cutter is a filter to cut through data using any subclass of vtk\-Implicit\-Function. That is, a polygonal surface is created corresponding to the implicit function F(x,y,z) = value(s), where you can specify one or more values used to cut with.

In V\-T\-K, cutting means reducing a cell of dimension N to a cut surface of dimension N-\/1. For example, a tetrahedron when cut by a plane (i.\-e., vtk\-Plane implicit function) will generate triangles. (In comparison, clipping takes a N dimensional cell and creates N dimension primitives.)

vtk\-Cutter is generally used to \char`\"{}slice-\/through\char`\"{} a dataset, generating a surface that can be visualized. It is also possible to use vtk\-Cutter to do a form of volume rendering. vtk\-Cutter does this by generating multiple cut surfaces (usually planes) which are ordered (and rendered) from back-\/to-\/front. The surfaces are set translucent to give a volumetric rendering effect.

Note that data can be cut using either 1) the scalar values associated with the dataset or 2) an implicit function associated with this class. By default, if an implicit function is set it is used to clip the data set, otherwise the dataset scalars are used to perform the clipping.

To create an instance of class vtk\-Cutter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCutter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Cutter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Cutter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Cutter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Cutter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Value (int i, double value)} -\/ Get the ith contour value.  
\item {\ttfamily double = obj.\-Get\-Value (int i)} -\/ Get a pointer to an array of contour values. There will be Get\-Number\-Of\-Contours() values in the list.  
\item {\ttfamily obj.\-Get\-Values (double contour\-Values)} -\/ Set the number of contours to place into the list. You only really need to use this method to reduce list size. The method Set\-Value() will automatically increase list size as needed.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Contours (int number)} -\/ Get the number of contours in the list of contour values.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Contours ()} -\/ Generate num\-Contours equally spaced contour values between specified range. Contour values will include min/max range values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\mbox{[}2\mbox{]})} -\/ Generate num\-Contours equally spaced contour values between specified range. Contour values will include min/max range values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\-Start, double range\-End)} -\/ Override Get\-M\-Time because we delegate to vtk\-Contour\-Values and refer to vtk\-Implicit\-Function.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Override Get\-M\-Time because we delegate to vtk\-Contour\-Values and refer to vtk\-Implicit\-Function.  
\item {\ttfamily obj.\-Set\-Cut\-Function (vtk\-Implicit\-Function )}  
\item {\ttfamily vtk\-Implicit\-Function = obj.\-Get\-Cut\-Function ()}  
\item {\ttfamily obj.\-Set\-Generate\-Cut\-Scalars (int )} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data.  
\item {\ttfamily int = obj.\-Get\-Generate\-Cut\-Scalars ()} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data.  
\item {\ttfamily obj.\-Generate\-Cut\-Scalars\-On ()} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data.  
\item {\ttfamily obj.\-Generate\-Cut\-Scalars\-Off ()} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data.  
\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.\-Set\-Sort\-By (int )} -\/ Set the sorting order for the generated polydata. There are two possibilities\-: Sort by value = 0 -\/ This is the most efficient sort. For each cell, all contour values are processed. This is the default. Sort by cell = 1 -\/ For each contour value, all cells are processed. This order should be used if the extracted polygons must be rendered in a back-\/to-\/front or front-\/to-\/back order. This is very problem dependent. For most applications, the default order is fine (and faster).

Sort by cell is going to have a problem if the input has 2\-D and 3\-D cells. Cell data will be scrambled becauses with vtk\-Poly\-Data output, verts and lines have lower cell ids than triangles.  
\item {\ttfamily int = obj.\-Get\-Sort\-By\-Min\-Value ()} -\/ Set the sorting order for the generated polydata. There are two possibilities\-: Sort by value = 0 -\/ This is the most efficient sort. For each cell, all contour values are processed. This is the default. Sort by cell = 1 -\/ For each contour value, all cells are processed. This order should be used if the extracted polygons must be rendered in a back-\/to-\/front or front-\/to-\/back order. This is very problem dependent. For most applications, the default order is fine (and faster).

Sort by cell is going to have a problem if the input has 2\-D and 3\-D cells. Cell data will be scrambled becauses with vtk\-Poly\-Data output, verts and lines have lower cell ids than triangles.  
\item {\ttfamily int = obj.\-Get\-Sort\-By\-Max\-Value ()} -\/ Set the sorting order for the generated polydata. There are two possibilities\-: Sort by value = 0 -\/ This is the most efficient sort. For each cell, all contour values are processed. This is the default. Sort by cell = 1 -\/ For each contour value, all cells are processed. This order should be used if the extracted polygons must be rendered in a back-\/to-\/front or front-\/to-\/back order. This is very problem dependent. For most applications, the default order is fine (and faster).

Sort by cell is going to have a problem if the input has 2\-D and 3\-D cells. Cell data will be scrambled becauses with vtk\-Poly\-Data output, verts and lines have lower cell ids than triangles.  
\item {\ttfamily int = obj.\-Get\-Sort\-By ()} -\/ Set the sorting order for the generated polydata. There are two possibilities\-: Sort by value = 0 -\/ This is the most efficient sort. For each cell, all contour values are processed. This is the default. Sort by cell = 1 -\/ For each contour value, all cells are processed. This order should be used if the extracted polygons must be rendered in a back-\/to-\/front or front-\/to-\/back order. This is very problem dependent. For most applications, the default order is fine (and faster).

Sort by cell is going to have a problem if the input has 2\-D and 3\-D cells. Cell data will be scrambled becauses with vtk\-Poly\-Data output, verts and lines have lower cell ids than triangles.  
\item {\ttfamily obj.\-Set\-Sort\-By\-To\-Sort\-By\-Value ()} -\/ Set the sorting order for the generated polydata. There are two possibilities\-: Sort by value = 0 -\/ This is the most efficient sort. For each cell, all contour values are processed. This is the default. Sort by cell = 1 -\/ For each contour value, all cells are processed. This order should be used if the extracted polygons must be rendered in a back-\/to-\/front or front-\/to-\/back order. This is very problem dependent. For most applications, the default order is fine (and faster).

Sort by cell is going to have a problem if the input has 2\-D and 3\-D cells. Cell data will be scrambled becauses with vtk\-Poly\-Data output, verts and lines have lower cell ids than triangles.  
\item {\ttfamily obj.\-Set\-Sort\-By\-To\-Sort\-By\-Cell ()} -\/ Set the sorting order for the generated polydata. There are two possibilities\-: Sort by value = 0 -\/ This is the most efficient sort. For each cell, all contour values are processed. This is the default. Sort by cell = 1 -\/ For each contour value, all cells are processed. This order should be used if the extracted polygons must be rendered in a back-\/to-\/front or front-\/to-\/back order. This is very problem dependent. For most applications, the default order is fine (and faster).

Sort by cell is going to have a problem if the input has 2\-D and 3\-D cells. Cell data will be scrambled becauses with vtk\-Poly\-Data output, verts and lines have lower cell ids than triangles.  
\item {\ttfamily string = obj.\-Get\-Sort\-By\-As\-String ()} -\/ Set the sorting order for the generated polydata. There are two possibilities\-: Sort by value = 0 -\/ This is the most efficient sort. For each cell, all contour values are processed. This is the default. Sort by cell = 1 -\/ For each contour value, all cells are processed. This order should be used if the extracted polygons must be rendered in a back-\/to-\/front or front-\/to-\/back order. This is very problem dependent. For most applications, the default order is fine (and faster).

Sort by cell is going to have a problem if the input has 2\-D and 3\-D cells. Cell data will be scrambled becauses with vtk\-Poly\-Data output, verts and lines have lower cell ids than triangles.  
\item {\ttfamily obj.\-Create\-Default\-Locator ()} -\/ Create default locator. Used to create one when none is specified. The locator is used to merge coincident points.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkcylindersource}{}\section{vtk\-Cylinder\-Source}\label{vtkgraphics_vtkcylindersource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Cylinder\-Source creates a polygonal cylinder centered at Center; The axis of the cylinder is aligned along the global y-\/axis. The height and radius of the cylinder can be specified, as well as the number of sides. It is also possible to control whether the cylinder is open-\/ended or capped.

To create an instance of class vtk\-Cylinder\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCylinderSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Cylinder\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Cylinder\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Cylinder\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Cylinder\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Height (double )} -\/ Set the height of the cylinder. Initial value is 1.  
\item {\ttfamily double = obj.\-Get\-Height\-Min\-Value ()} -\/ Set the height of the cylinder. Initial value is 1.  
\item {\ttfamily double = obj.\-Get\-Height\-Max\-Value ()} -\/ Set the height of the cylinder. Initial value is 1.  
\item {\ttfamily double = obj.\-Get\-Height ()} -\/ Set the height of the cylinder. Initial value is 1.  
\item {\ttfamily obj.\-Set\-Radius (double )} -\/ Set the radius of the cylinder. Initial value is 0.\-5  
\item {\ttfamily double = obj.\-Get\-Radius\-Min\-Value ()} -\/ Set the radius of the cylinder. Initial value is 0.\-5  
\item {\ttfamily double = obj.\-Get\-Radius\-Max\-Value ()} -\/ Set the radius of the cylinder. Initial value is 0.\-5  
\item {\ttfamily double = obj.\-Get\-Radius ()} -\/ Set the radius of the cylinder. Initial value is 0.\-5  
\item {\ttfamily obj.\-Set\-Center (double , double , double )} -\/ Set/\-Get cylinder center. Initial value is (0.\-0,0.\-0,0.\-0)  
\item {\ttfamily obj.\-Set\-Center (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get cylinder center. Initial value is (0.\-0,0.\-0,0.\-0)  
\item {\ttfamily double = obj. Get\-Center ()} -\/ Set/\-Get cylinder center. Initial value is (0.\-0,0.\-0,0.\-0)  
\item {\ttfamily obj.\-Set\-Resolution (int )} -\/ Set the number of facets used to define cylinder. Initial value is 6.  
\item {\ttfamily int = obj.\-Get\-Resolution\-Min\-Value ()} -\/ Set the number of facets used to define cylinder. Initial value is 6.  
\item {\ttfamily int = obj.\-Get\-Resolution\-Max\-Value ()} -\/ Set the number of facets used to define cylinder. Initial value is 6.  
\item {\ttfamily int = obj.\-Get\-Resolution ()} -\/ Set the number of facets used to define cylinder. Initial value is 6.  
\item {\ttfamily obj.\-Set\-Capping (int )} -\/ Turn on/off whether to cap cylinder with polygons. Initial value is true.  
\item {\ttfamily int = obj.\-Get\-Capping ()} -\/ Turn on/off whether to cap cylinder with polygons. Initial value is true.  
\item {\ttfamily obj.\-Capping\-On ()} -\/ Turn on/off whether to cap cylinder with polygons. Initial value is true.  
\item {\ttfamily obj.\-Capping\-Off ()} -\/ Turn on/off whether to cap cylinder with polygons. Initial value is true.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkdashedstreamline}{}\section{vtk\-Dashed\-Stream\-Line}\label{vtkgraphics_vtkdashedstreamline}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Dashed\-Stream\-Line is a filter that generates a \char`\"{}dashed\char`\"{} streamline for an arbitrary dataset. The streamline consists of a series of dashes, each of which represents (approximately) a constant time increment. Thus, in the resulting visual representation, relatively long dashes represent areas of high velocity, and small dashes represent areas of low velocity.

vtk\-Dashed\-Stream\-Line introduces the instance variable Dash\-Factor. Dash\-Factor interacts with its superclass' instance variable Step\-Length to create the dashes. Dash\-Factor is the percentage of the Step\-Length line segment that is visible. Thus, if the Dash\-Factor=0.\-75, the dashes will be \char`\"{}three-\/quarters on\char`\"{} and \char`\"{}one-\/quarter off\char`\"{}.

To create an instance of class vtk\-Dashed\-Stream\-Line, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDashedStreamLine
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Dashed\-Stream\-Line has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Dashed\-Stream\-Line class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Dashed\-Stream\-Line = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Dashed\-Stream\-Line = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Dash\-Factor (double )} -\/ For each dash, specify the fraction of the dash that is \char`\"{}on\char`\"{}. A factor of 1.\-0 will result in a continuous line, a factor of 0.\-5 will result in dashed that are half on and half off.  
\item {\ttfamily double = obj.\-Get\-Dash\-Factor\-Min\-Value ()} -\/ For each dash, specify the fraction of the dash that is \char`\"{}on\char`\"{}. A factor of 1.\-0 will result in a continuous line, a factor of 0.\-5 will result in dashed that are half on and half off.  
\item {\ttfamily double = obj.\-Get\-Dash\-Factor\-Max\-Value ()} -\/ For each dash, specify the fraction of the dash that is \char`\"{}on\char`\"{}. A factor of 1.\-0 will result in a continuous line, a factor of 0.\-5 will result in dashed that are half on and half off.  
\item {\ttfamily double = obj.\-Get\-Dash\-Factor ()} -\/ For each dash, specify the fraction of the dash that is \char`\"{}on\char`\"{}. A factor of 1.\-0 will result in a continuous line, a factor of 0.\-5 will result in dashed that are half on and half off.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkdataobjectgenerator}{}\section{vtk\-Data\-Object\-Generator}\label{vtkgraphics_vtkdataobjectgenerator}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Data\-Object\-Generator parses a string and produces dataobjects from the dataobject template names it sees in the string. For example, if the string contains \char`\"{}\-I\-D1\char`\"{} the generator will create a vtk\-Image\-Data. \char`\"{}\-U\-F1\char`\"{}, \char`\"{}\-R\-G1\char`\"{}, \char`\"{}\-S\-G1\char`\"{}, \char`\"{}\-P\-D1\char`\"{}, and \char`\"{}\-U\-G1\char`\"{} will produce vtk\-Uniform\-Grid, vtk\-Rectilinear\-Grid, vtk\-Structured\-Grid, vtk\-Poly\-Data and vtk\-Unstructured\-Grid respectively. \char`\"{}\-P\-D2\char`\"{} will produce an alternate vtk\-Poly\-Data. You can compose composite datasets from the atomic ones listed above by placing them within one of the two composite dataset identifiers
\begin{DoxyItemize}
\item \char`\"{}\-M\-B\{\}\char`\"{} or \char`\"{}\-H\-B\mbox{[}$\,$\mbox{]}\char`\"{}. \char`\"{}\-M\-B\{ I\-D1 P\-D1 M\-B\{\} \}\char`\"{} for example will create a vtk\-Multi\-Block\-Data\-Set consisting of three blocks\-: image data, poly data, multi-\/block (empty). Hierarchical Box data sets additionally require the notion of groups, declared within \char`\"{}()\char`\"{} braces, to specify A\-M\-R depth. \char`\"{}\-H\-B\mbox{[} (\-U\-F1)(\-U\-F1)(\-U\-F1) \mbox{]}\char`\"{} will create a vtk\-Hierarchical\-Box\-Data\-Set representing an octree that is three levels deep, in which the firstmost cell in each level is refined.
\end{DoxyItemize}

To create an instance of class vtk\-Data\-Object\-Generator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDataObjectGenerator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Data\-Object\-Generator has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Generator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Data\-Object\-Generator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Data\-Object\-Generator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Program (string )} -\/ The string that will be parsed to specify a dataobject structure.  
\item {\ttfamily string = obj.\-Get\-Program ()} -\/ The string that will be parsed to specify a dataobject structure.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkdataobjecttodatasetfilter}{}\section{vtk\-Data\-Object\-To\-Data\-Set\-Filter}\label{vtkgraphics_vtkdataobjecttodatasetfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Data\-Object\-To\-Data\-Set\-Filter is an class that maps a data object (i.\-e., a field) into a concrete dataset, i.\-e., gives structure to the field by defining a geometry and topology.

To use this filter you associate components in the input field data with portions of the output dataset. (A component is an array of values from the field.) For example, you would specify x-\/y-\/z points by assigning components from the field for the x, then y, then z values of the points. You may also have to specify component ranges (for each z-\/y-\/z) to make sure that the number of x, y, and z values is the same. Also, you may want to normalize the components which helps distribute the data uniformly. Once you've setup the filter to combine all the pieces of data into a specified dataset (the geometry, topology, point and cell data attributes), the various output methods (e.\-g., Get\-Poly\-Data()) are used to retrieve the final product.

This filter is often used in conjunction with vtk\-Field\-Data\-To\-Attribute\-Data\-Filter. vtk\-Field\-Data\-To\-Attribute\-Data\-Filter takes field data and transforms it into attribute data (e.\-g., point and cell data attributes such as scalars and vectors). To do this, use this filter which constructs a concrete dataset and passes the input data object field data to its output. and then use vtk\-Field\-Data\-To\-Attribute\-Data\-Filter to generate the attribute data associated with the dataset.

To create an instance of class vtk\-Data\-Object\-To\-Data\-Set\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDataObjectToDataSetFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Data\-Object\-To\-Data\-Set\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-To\-Data\-Set\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Data\-Object\-To\-Data\-Set\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Data\-Object\-To\-Data\-Set\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Input ()} -\/ Get the input to the filter.  
\item {\ttfamily obj.\-Set\-Data\-Set\-Type (int )} -\/ Control what type of data is generated for output.  
\item {\ttfamily int = obj.\-Get\-Data\-Set\-Type ()} -\/ Control what type of data is generated for output.  
\item {\ttfamily obj.\-Set\-Data\-Set\-Type\-To\-Poly\-Data ()} -\/ Control what type of data is generated for output.  
\item {\ttfamily obj.\-Set\-Data\-Set\-Type\-To\-Structured\-Points ()} -\/ Control what type of data is generated for output.  
\item {\ttfamily obj.\-Set\-Data\-Set\-Type\-To\-Structured\-Grid ()} -\/ Control what type of data is generated for output.  
\item {\ttfamily obj.\-Set\-Data\-Set\-Type\-To\-Rectilinear\-Grid ()} -\/ Control what type of data is generated for output.  
\item {\ttfamily obj.\-Set\-Data\-Set\-Type\-To\-Unstructured\-Grid ()} -\/ Control what type of data is generated for output.  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Output ()} -\/ Get the output in different forms. The particular method invoked should be consistent with the Set\-Data\-Set\-Type() method. (Note\-: Get\-Output() will always return a type consistent with Set\-Data\-Set\-Type(). Also, Get\-Output() will return N\-U\-L\-L if the filter aborted due to inconsistent data.)  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Output (int idx)} -\/ Get the output in different forms. The particular method invoked should be consistent with the Set\-Data\-Set\-Type() method. (Note\-: Get\-Output() will always return a type consistent with Set\-Data\-Set\-Type(). Also, Get\-Output() will return N\-U\-L\-L if the filter aborted due to inconsistent data.)  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Poly\-Data\-Output ()} -\/ Get the output in different forms. The particular method invoked should be consistent with the Set\-Data\-Set\-Type() method. (Note\-: Get\-Output() will always return a type consistent with Set\-Data\-Set\-Type(). Also, Get\-Output() will return N\-U\-L\-L if the filter aborted due to inconsistent data.)  
\item {\ttfamily vtk\-Structured\-Points = obj.\-Get\-Structured\-Points\-Output ()} -\/ Get the output in different forms. The particular method invoked should be consistent with the Set\-Data\-Set\-Type() method. (Note\-: Get\-Output() will always return a type consistent with Set\-Data\-Set\-Type(). Also, Get\-Output() will return N\-U\-L\-L if the filter aborted due to inconsistent data.)  
\item {\ttfamily vtk\-Structured\-Grid = obj.\-Get\-Structured\-Grid\-Output ()} -\/ Get the output in different forms. The particular method invoked should be consistent with the Set\-Data\-Set\-Type() method. (Note\-: Get\-Output() will always return a type consistent with Set\-Data\-Set\-Type(). Also, Get\-Output() will return N\-U\-L\-L if the filter aborted due to inconsistent data.)  
\item {\ttfamily vtk\-Unstructured\-Grid = obj.\-Get\-Unstructured\-Grid\-Output ()} -\/ Get the output in different forms. The particular method invoked should be consistent with the Set\-Data\-Set\-Type() method. (Note\-: Get\-Output() will always return a type consistent with Set\-Data\-Set\-Type(). Also, Get\-Output() will return N\-U\-L\-L if the filter aborted due to inconsistent data.)  
\item {\ttfamily vtk\-Rectilinear\-Grid = obj.\-Get\-Rectilinear\-Grid\-Output ()} -\/ Get the output in different forms. The particular method invoked should be consistent with the Set\-Data\-Set\-Type() method. (Note\-: Get\-Output() will always return a type consistent with Set\-Data\-Set\-Type(). Also, Get\-Output() will return N\-U\-L\-L if the filter aborted due to inconsistent data.)  
\item {\ttfamily obj.\-Set\-Point\-Component (int comp, string array\-Name, int array\-Comp, int min, int max, int normalize)} -\/ Define the component of the field to be used for the x, y, and z values of the points. Note that the parameter comp must lie between (0,2) and refers to the x-\/y-\/z (i.\-e., 0,1,2) components of the points. To define the field component to use you can specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract. (This method should be used for vtk\-Poly\-Data, vtk\-Unstructured\-Grid, vtk\-Structured\-Grid, and vtk\-Rectilinear\-Grid.) A convenience method, Set\-Point\-Component(),is also provided which does not require setting the (min,max) component range or the normalize flag (normalize is set to Defaulat\-Normalize value).  
\item {\ttfamily obj.\-Set\-Point\-Component (int comp, string array\-Name, int array\-Comp)} -\/ Define the component of the field to be used for the x, y, and z values of the points. Note that the parameter comp must lie between (0,2) and refers to the x-\/y-\/z (i.\-e., 0,1,2) components of the points. To define the field component to use you can specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract. (This method should be used for vtk\-Poly\-Data, vtk\-Unstructured\-Grid, vtk\-Structured\-Grid, and vtk\-Rectilinear\-Grid.) A convenience method, Set\-Point\-Component(),is also provided which does not require setting the (min,max) component range or the normalize flag (normalize is set to Defaulat\-Normalize value).  
\item {\ttfamily string = obj.\-Get\-Point\-Component\-Array\-Name (int comp)} -\/ Define the component of the field to be used for the x, y, and z values of the points. Note that the parameter comp must lie between (0,2) and refers to the x-\/y-\/z (i.\-e., 0,1,2) components of the points. To define the field component to use you can specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract. (This method should be used for vtk\-Poly\-Data, vtk\-Unstructured\-Grid, vtk\-Structured\-Grid, and vtk\-Rectilinear\-Grid.) A convenience method, Set\-Point\-Component(),is also provided which does not require setting the (min,max) component range or the normalize flag (normalize is set to Defaulat\-Normalize value).  
\item {\ttfamily int = obj.\-Get\-Point\-Component\-Array\-Component (int comp)} -\/ Define the component of the field to be used for the x, y, and z values of the points. Note that the parameter comp must lie between (0,2) and refers to the x-\/y-\/z (i.\-e., 0,1,2) components of the points. To define the field component to use you can specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract. (This method should be used for vtk\-Poly\-Data, vtk\-Unstructured\-Grid, vtk\-Structured\-Grid, and vtk\-Rectilinear\-Grid.) A convenience method, Set\-Point\-Component(),is also provided which does not require setting the (min,max) component range or the normalize flag (normalize is set to Defaulat\-Normalize value).  
\item {\ttfamily int = obj.\-Get\-Point\-Component\-Min\-Range (int comp)} -\/ Define the component of the field to be used for the x, y, and z values of the points. Note that the parameter comp must lie between (0,2) and refers to the x-\/y-\/z (i.\-e., 0,1,2) components of the points. To define the field component to use you can specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract. (This method should be used for vtk\-Poly\-Data, vtk\-Unstructured\-Grid, vtk\-Structured\-Grid, and vtk\-Rectilinear\-Grid.) A convenience method, Set\-Point\-Component(),is also provided which does not require setting the (min,max) component range or the normalize flag (normalize is set to Defaulat\-Normalize value).  
\item {\ttfamily int = obj.\-Get\-Point\-Component\-Max\-Range (int comp)} -\/ Define the component of the field to be used for the x, y, and z values of the points. Note that the parameter comp must lie between (0,2) and refers to the x-\/y-\/z (i.\-e., 0,1,2) components of the points. To define the field component to use you can specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract. (This method should be used for vtk\-Poly\-Data, vtk\-Unstructured\-Grid, vtk\-Structured\-Grid, and vtk\-Rectilinear\-Grid.) A convenience method, Set\-Point\-Component(),is also provided which does not require setting the (min,max) component range or the normalize flag (normalize is set to Defaulat\-Normalize value).  
\item {\ttfamily int = obj.\-Get\-Point\-Component\-Normailze\-Flag (int comp)} -\/ Define the component of the field to be used for the x, y, and z values of the points. Note that the parameter comp must lie between (0,2) and refers to the x-\/y-\/z (i.\-e., 0,1,2) components of the points. To define the field component to use you can specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract. (This method should be used for vtk\-Poly\-Data, vtk\-Unstructured\-Grid, vtk\-Structured\-Grid, and vtk\-Rectilinear\-Grid.) A convenience method, Set\-Point\-Component(),is also provided which does not require setting the (min,max) component range or the normalize flag (normalize is set to Defaulat\-Normalize value).  
\item {\ttfamily obj.\-Set\-Verts\-Component (string array\-Name, int array\-Comp, int min, int max)} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily obj.\-Set\-Verts\-Component (string array\-Name, int array\-Comp)} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily string = obj.\-Get\-Verts\-Component\-Array\-Name ()} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily int = obj.\-Get\-Verts\-Component\-Array\-Component ()} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily int = obj.\-Get\-Verts\-Component\-Min\-Range ()} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily int = obj.\-Get\-Verts\-Component\-Max\-Range ()} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily obj.\-Set\-Lines\-Component (string array\-Name, int array\-Comp, int min, int max)} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily obj.\-Set\-Lines\-Component (string array\-Name, int array\-Comp)} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily string = obj.\-Get\-Lines\-Component\-Array\-Name ()} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily int = obj.\-Get\-Lines\-Component\-Array\-Component ()} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily int = obj.\-Get\-Lines\-Component\-Min\-Range ()} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily int = obj.\-Get\-Lines\-Component\-Max\-Range ()} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily obj.\-Set\-Polys\-Component (string array\-Name, int array\-Comp, int min, int max)} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily obj.\-Set\-Polys\-Component (string array\-Name, int array\-Comp)} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily string = obj.\-Get\-Polys\-Component\-Array\-Name ()} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily int = obj.\-Get\-Polys\-Component\-Array\-Component ()} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily int = obj.\-Get\-Polys\-Component\-Min\-Range ()} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily int = obj.\-Get\-Polys\-Component\-Max\-Range ()} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily obj.\-Set\-Strips\-Component (string array\-Name, int array\-Comp, int min, int max)} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily obj.\-Set\-Strips\-Component (string array\-Name, int array\-Comp)} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily string = obj.\-Get\-Strips\-Component\-Array\-Name ()} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily int = obj.\-Get\-Strips\-Component\-Array\-Component ()} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily int = obj.\-Get\-Strips\-Component\-Min\-Range ()} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily int = obj.\-Get\-Strips\-Component\-Max\-Range ()} -\/ Define cell connectivity when creating vtk\-Poly\-Data. You can define vertices, lines, polygons, and/or triangle strips via these methods. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of values that (for each cell) includes the number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily obj.\-Set\-Cell\-Type\-Component (string array\-Name, int array\-Comp, int min, int max)} -\/ Define cell types and cell connectivity when creating unstructured grid data. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of cell types (an integer value per cell), and another array consisting (for each cell) of a number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily obj.\-Set\-Cell\-Type\-Component (string array\-Name, int array\-Comp)} -\/ Define cell types and cell connectivity when creating unstructured grid data. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of cell types (an integer value per cell), and another array consisting (for each cell) of a number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily string = obj.\-Get\-Cell\-Type\-Component\-Array\-Name ()} -\/ Define cell types and cell connectivity when creating unstructured grid data. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of cell types (an integer value per cell), and another array consisting (for each cell) of a number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily int = obj.\-Get\-Cell\-Type\-Component\-Array\-Component ()} -\/ Define cell types and cell connectivity when creating unstructured grid data. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of cell types (an integer value per cell), and another array consisting (for each cell) of a number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily int = obj.\-Get\-Cell\-Type\-Component\-Min\-Range ()} -\/ Define cell types and cell connectivity when creating unstructured grid data. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of cell types (an integer value per cell), and another array consisting (for each cell) of a number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily int = obj.\-Get\-Cell\-Type\-Component\-Max\-Range ()} -\/ Define cell types and cell connectivity when creating unstructured grid data. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of cell types (an integer value per cell), and another array consisting (for each cell) of a number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily obj.\-Set\-Cell\-Connectivity\-Component (string array\-Name, int array\-Comp, int min, int max)} -\/ Define cell types and cell connectivity when creating unstructured grid data. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of cell types (an integer value per cell), and another array consisting (for each cell) of a number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily obj.\-Set\-Cell\-Connectivity\-Component (string array\-Name, int array\-Comp)} -\/ Define cell types and cell connectivity when creating unstructured grid data. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of cell types (an integer value per cell), and another array consisting (for each cell) of a number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily string = obj.\-Get\-Cell\-Connectivity\-Component\-Array\-Name ()} -\/ Define cell types and cell connectivity when creating unstructured grid data. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of cell types (an integer value per cell), and another array consisting (for each cell) of a number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily int = obj.\-Get\-Cell\-Connectivity\-Component\-Array\-Component ()} -\/ Define cell types and cell connectivity when creating unstructured grid data. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of cell types (an integer value per cell), and another array consisting (for each cell) of a number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily int = obj.\-Get\-Cell\-Connectivity\-Component\-Min\-Range ()} -\/ Define cell types and cell connectivity when creating unstructured grid data. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of cell types (an integer value per cell), and another array consisting (for each cell) of a number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily int = obj.\-Get\-Cell\-Connectivity\-Component\-Max\-Range ()} -\/ Define cell types and cell connectivity when creating unstructured grid data. These methods are similar to those for defining points, except that no normalization of the data is possible. Basically, you need to define an array of cell types (an integer value per cell), and another array consisting (for each cell) of a number of points per cell, and then the cell connectivity. (This is the vtk file format described in in the textbook or User's Guide.)  
\item {\ttfamily obj.\-Set\-Default\-Normalize (int )} -\/ Set the default Normalize() flag for those methods setting a default Normalize value (e.\-g., Set\-Point\-Component).  
\item {\ttfamily int = obj.\-Get\-Default\-Normalize ()} -\/ Set the default Normalize() flag for those methods setting a default Normalize value (e.\-g., Set\-Point\-Component).  
\item {\ttfamily obj.\-Default\-Normalize\-On ()} -\/ Set the default Normalize() flag for those methods setting a default Normalize value (e.\-g., Set\-Point\-Component).  
\item {\ttfamily obj.\-Default\-Normalize\-Off ()} -\/ Set the default Normalize() flag for those methods setting a default Normalize value (e.\-g., Set\-Point\-Component).  
\item {\ttfamily obj.\-Set\-Dimensions (int , int , int )}  
\item {\ttfamily obj.\-Set\-Dimensions (int a\mbox{[}3\mbox{]})}  
\item {\ttfamily int = obj. Get\-Dimensions ()}  
\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\-Dimensions\-Component (string array\-Name, int array\-Comp, int min, int max)}  
\item {\ttfamily obj.\-Set\-Dimensions\-Component (string array\-Name, int array\-Comp)}  
\item {\ttfamily obj.\-Set\-Spacing\-Component (string array\-Name, int array\-Comp, int min, int max)}  
\item {\ttfamily obj.\-Set\-Spacing\-Component (string array\-Name, int array\-Comp)}  
\item {\ttfamily obj.\-Set\-Origin\-Component (string array\-Name, int array\-Comp, int min, int max)}  
\item {\ttfamily obj.\-Set\-Origin\-Component (string array\-Name, int array\-Comp)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkdatasetedgesubdivisioncriterion}{}\section{vtk\-Data\-Set\-Edge\-Subdivision\-Criterion}\label{vtkgraphics_vtkdatasetedgesubdivisioncriterion}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is a subclass of vtk\-Edge\-Subdivision\-Criterion that is used for tessellating cells of a vtk\-Data\-Set, particularly nonlinear cells.

It provides functions for setting the current cell being tessellated and a convenience routine, {\itshape Evaluate\-Fields()} to evaluate field values at a point. You should call {\itshape Evaluate\-Fields()} from inside {\itshape Evaluate\-Edge()} whenever the result of {\itshape Evaluate\-Edge()} will be true. Otherwise, do not call {\itshape Evaluate\-Fields()} as the midpoint is about to be discarded. ({\itshape Implementor's note}\-: This isn't true if U\-G\-L\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O\-\_\-\-H\-A\-C\-K has been defined. But in that case, we don't want the exact field values; we need the linearly interpolated ones at the midpoint for continuity.)

To create an instance of class vtk\-Data\-Set\-Edge\-Subdivision\-Criterion, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDataSetEdgeSubdivisionCriterion
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Data\-Set\-Edge\-Subdivision\-Criterion has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Edge\-Subdivision\-Criterion class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Data\-Set\-Edge\-Subdivision\-Criterion = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Data\-Set\-Edge\-Subdivision\-Criterion = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Mesh (vtk\-Data\-Set )}  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Mesh ()}  
\item {\ttfamily obj.\-Set\-Cell\-Id (vtk\-Id\-Type cell)}  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Cell\-Id () const}  
\item {\ttfamily vtk\-Cell = obj.\-Get\-Cell ()}  
\item {\ttfamily bool = obj.\-Evaluate\-Edge (double p0, double midpt, double p1, int field\-\_\-start)}  
\item {\ttfamily obj.\-Evaluate\-Point\-Data\-Field (double result, double weights, int field)} -\/ Evaluate either a cell or nodal field. This exists because of the funky way that Exodus data will be handled. Sure, it's a hack, but what are ya gonna do?  
\item {\ttfamily obj.\-Evaluate\-Cell\-Data\-Field (double result, double weights, int field)} -\/ Evaluate either a cell or nodal field. This exists because of the funky way that Exodus data will be handled. Sure, it's a hack, but what are ya gonna do?  
\item {\ttfamily obj.\-Set\-Chord\-Error2 (double )} -\/ Get/\-Set the square of the allowable chord error at any edge's midpoint. This value is used by Evaluate\-Edge.  
\item {\ttfamily double = obj.\-Get\-Chord\-Error2 ()} -\/ Get/\-Set the square of the allowable chord error at any edge's midpoint. This value is used by Evaluate\-Edge.  
\item {\ttfamily obj.\-Set\-Field\-Error2 (int s, double err)} -\/ Get/\-Set the square of the allowable error magnitude for the scalar field {\itshape s} at any edge's midpoint. A value less than or equal to 0 indicates that the field should not be used as a criterion for subdivision.  
\item {\ttfamily double = obj.\-Get\-Field\-Error2 (int s) const} -\/ Get/\-Set the square of the allowable error magnitude for the scalar field {\itshape s} at any edge's midpoint. A value less than or equal to 0 indicates that the field should not be used as a criterion for subdivision.  
\item {\ttfamily obj.\-Reset\-Field\-Error2 ()} -\/ Tell the subdivider not to use any field values as subdivision criteria. Effectively calls Set\-Field\-Error2( a, -\/1. ) for all fields.  
\item {\ttfamily int = obj.\-Get\-Active\-Field\-Criteria ()} -\/ Return a bitfield specifying which Field\-Error2 criteria are positive (i.\-e., actively used to decide edge subdivisions). This is stored as separate state to make subdivisions go faster.  
\item {\ttfamily int = obj.\-Get\-Active\-Field\-Criteria () const}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkdatasetgradient}{}\section{vtk\-Data\-Set\-Gradient}\label{vtkgraphics_vtkdatasetgradient}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Data\-Set\-Gradient Computes per cell gradient of point scalar field or per point gradient of cell scalar field.

.S\-E\-C\-T\-I\-O\-N Thanks This file is part of the generalized Youngs material interface reconstruction algorithm contributed by C\-E\-A/\-D\-I\-F -\/ Commissariat a l'Energie Atomique, Centre D\-A\-M Ile-\/\-De-\/\-France \par
 B\-P12, F-\/91297 Arpajon, France. \par
 Implementation by Thierry Carrard (C\-E\-A)

To create an instance of class vtk\-Data\-Set\-Gradient, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDataSetGradient
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Data\-Set\-Gradient has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Gradient class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Data\-Set\-Gradient = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Data\-Set\-Gradient = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Result\-Array\-Name (string )} -\/ Set/\-Get the name of computed vector array.  
\item {\ttfamily string = obj.\-Get\-Result\-Array\-Name ()} -\/ Set/\-Get the name of computed vector array.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkdatasetgradientprecompute}{}\section{vtk\-Data\-Set\-Gradient\-Precompute}\label{vtkgraphics_vtkdatasetgradientprecompute}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Computes a geometry based vector field that the Data\-Set\-Gradient filter uses to accelerate gradient computation. This vector field is added to Field\-Data since it has a different value for each vertex of each cell (a vertex shared by two cell has two differents values).

.S\-E\-C\-T\-I\-O\-N Thanks This file is part of the generalized Youngs material interface reconstruction algorithm contributed by C\-E\-A/\-D\-I\-F -\/ Commissariat a l'Energie Atomique, Centre D\-A\-M Ile-\/\-De-\/\-France \par
 B\-P12, F-\/91297 Arpajon, France. \par
 Implementation by Thierry Carrard (C\-E\-A)

To create an instance of class vtk\-Data\-Set\-Gradient\-Precompute, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDataSetGradientPrecompute
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Data\-Set\-Gradient\-Precompute has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Gradient\-Precompute class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Data\-Set\-Gradient\-Precompute = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Data\-Set\-Gradient\-Precompute = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkdatasetsurfacefilter}{}\section{vtk\-Data\-Set\-Surface\-Filter}\label{vtkgraphics_vtkdatasetsurfacefilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Data\-Set\-Surface\-Filter is a faster version of vtk\-Geometry filter, but it does not have an option to select bounds. It may use more memory than vtk\-Geometry\-Filter. It only has one option\-: whether to use triangle strips when the input type is structured.

To create an instance of class vtk\-Data\-Set\-Surface\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDataSetSurfaceFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Data\-Set\-Surface\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Surface\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Data\-Set\-Surface\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Data\-Set\-Surface\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Use\-Strips (int )} -\/ When input is structured data, this flag will generate faces with triangle strips. This should render faster and use less memory, but no cell data is copied. By default, Use\-Strips is Off.  
\item {\ttfamily int = obj.\-Get\-Use\-Strips ()} -\/ When input is structured data, this flag will generate faces with triangle strips. This should render faster and use less memory, but no cell data is copied. By default, Use\-Strips is Off.  
\item {\ttfamily obj.\-Use\-Strips\-On ()} -\/ When input is structured data, this flag will generate faces with triangle strips. This should render faster and use less memory, but no cell data is copied. By default, Use\-Strips is Off.  
\item {\ttfamily obj.\-Use\-Strips\-Off ()} -\/ When input is structured data, this flag will generate faces with triangle strips. This should render faster and use less memory, but no cell data is copied. By default, Use\-Strips is Off.  
\item {\ttfamily obj.\-Set\-Piece\-Invariant (int )} -\/ If Piece\-Invariant is true, vtk\-Data\-Set\-Surface\-Filter requests 1 ghost level from input in order to remove internal surface that are between processes. False by default.  
\item {\ttfamily int = obj.\-Get\-Piece\-Invariant ()} -\/ If Piece\-Invariant is true, vtk\-Data\-Set\-Surface\-Filter requests 1 ghost level from input in order to remove internal surface that are between processes. False by default.  
\item {\ttfamily obj.\-Set\-Pass\-Through\-Cell\-Ids (int )} -\/ If on, the output polygonal dataset will have a celldata array that holds the cell index of the original 3\-D cell that produced each output cell. This is useful for cell picking. The default is off to conserve memory. Note that Pass\-Through\-Cell\-Ids will be ignored if Use\-Strips is on, since in that case each tringle strip can represent more than on of the input cells.  
\item {\ttfamily int = obj.\-Get\-Pass\-Through\-Cell\-Ids ()} -\/ If on, the output polygonal dataset will have a celldata array that holds the cell index of the original 3\-D cell that produced each output cell. This is useful for cell picking. The default is off to conserve memory. Note that Pass\-Through\-Cell\-Ids will be ignored if Use\-Strips is on, since in that case each tringle strip can represent more than on of the input cells.  
\item {\ttfamily obj.\-Pass\-Through\-Cell\-Ids\-On ()} -\/ If on, the output polygonal dataset will have a celldata array that holds the cell index of the original 3\-D cell that produced each output cell. This is useful for cell picking. The default is off to conserve memory. Note that Pass\-Through\-Cell\-Ids will be ignored if Use\-Strips is on, since in that case each tringle strip can represent more than on of the input cells.  
\item {\ttfamily obj.\-Pass\-Through\-Cell\-Ids\-Off ()} -\/ If on, the output polygonal dataset will have a celldata array that holds the cell index of the original 3\-D cell that produced each output cell. This is useful for cell picking. The default is off to conserve memory. Note that Pass\-Through\-Cell\-Ids will be ignored if Use\-Strips is on, since in that case each tringle strip can represent more than on of the input cells.  
\item {\ttfamily obj.\-Set\-Pass\-Through\-Point\-Ids (int )} -\/ If on, the output polygonal dataset will have a celldata array that holds the cell index of the original 3\-D cell that produced each output cell. This is useful for cell picking. The default is off to conserve memory. Note that Pass\-Through\-Cell\-Ids will be ignored if Use\-Strips is on, since in that case each tringle strip can represent more than on of the input cells.  
\item {\ttfamily int = obj.\-Get\-Pass\-Through\-Point\-Ids ()} -\/ If on, the output polygonal dataset will have a celldata array that holds the cell index of the original 3\-D cell that produced each output cell. This is useful for cell picking. The default is off to conserve memory. Note that Pass\-Through\-Cell\-Ids will be ignored if Use\-Strips is on, since in that case each tringle strip can represent more than on of the input cells.  
\item {\ttfamily obj.\-Pass\-Through\-Point\-Ids\-On ()} -\/ If on, the output polygonal dataset will have a celldata array that holds the cell index of the original 3\-D cell that produced each output cell. This is useful for cell picking. The default is off to conserve memory. Note that Pass\-Through\-Cell\-Ids will be ignored if Use\-Strips is on, since in that case each tringle strip can represent more than on of the input cells.  
\item {\ttfamily obj.\-Pass\-Through\-Point\-Ids\-Off ()} -\/ If on, the output polygonal dataset will have a celldata array that holds the cell index of the original 3\-D cell that produced each output cell. This is useful for cell picking. The default is off to conserve memory. Note that Pass\-Through\-Cell\-Ids will be ignored if Use\-Strips is on, since in that case each tringle strip can represent more than on of the input cells.  
\item {\ttfamily int = obj.\-Structured\-Execute (vtk\-Data\-Set input, vtk\-Poly\-Data output, int ext32, int whole\-Ext32)} -\/ Direct access methods that can be used to use the this class as an algorithm without using it as a filter.  
\item {\ttfamily int = obj.\-Unstructured\-Grid\-Execute (vtk\-Data\-Set input, vtk\-Poly\-Data output)} -\/ Direct access methods that can be used to use the this class as an algorithm without using it as a filter.  
\item {\ttfamily int = obj.\-Data\-Set\-Execute (vtk\-Data\-Set input, vtk\-Poly\-Data output)} -\/ Direct access methods that can be used to use the this class as an algorithm without using it as a filter.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkdatasettodataobjectfilter}{}\section{vtk\-Data\-Set\-To\-Data\-Object\-Filter}\label{vtkgraphics_vtkdatasettodataobjectfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Data\-Set\-To\-Data\-Object\-Filter is an class that transforms a dataset into data object (i.\-e., a field). The field will have labeled data arrays corresponding to the topology, geometry, field data, and point and cell attribute data.

You can control what portions of the dataset are converted into the output data object's field data. The instance variables Geometry, Topology, Field\-Data, Point\-Data, and Cell\-Data are flags that control whether the dataset's geometry (e.\-g., points, spacing, origin); topology (e.\-g., cell connectivity, dimensions); the field data associated with the dataset's superclass data object; the dataset's point data attributes; and the dataset's cell data attributes. (Note\-: the data attributes include scalars, vectors, tensors, normals, texture coordinates, and field data.)

The names used to create the field data are as follows. For vtk\-Poly\-Data, \char`\"{}\-Points\char`\"{}, \char`\"{}\-Verts\char`\"{}, \char`\"{}\-Lines\char`\"{}, \char`\"{}\-Polys\char`\"{}, and \char`\"{}\-Strips\char`\"{}. For vtk\-Unstructured\-Grid, \char`\"{}\-Cells\char`\"{} and \char`\"{}\-Cell\-Types\char`\"{}. For vtk\-Structured\-Points, \char`\"{}\-Dimensions\char`\"{}, \char`\"{}\-Spacing\char`\"{}, and \char`\"{}\-Origin\char`\"{}. For vtk\-Structured\-Grid, \char`\"{}\-Points\char`\"{} and \char`\"{}\-Dimensions\char`\"{}. For vtk\-Rectilinear\-Grid, \char`\"{}\-X\-Coordinates\char`\"{}, \char`\"{}\-Y\-Coordinates\char`\"{}, and \char`\"{}\-Z\-Coordinates\char`\"{}. for point attribute data, \char`\"{}\-Point\-Scalars\char`\"{}, \char`\"{}\-Point\-Vectors\char`\"{}, etc. For cell attribute data, \char`\"{}\-Cell\-Scalars\char`\"{}, \char`\"{}\-Cell\-Vectors\char`\"{}, etc. Field data arrays retain their original name.

To create an instance of class vtk\-Data\-Set\-To\-Data\-Object\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDataSetToDataObjectFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Data\-Set\-To\-Data\-Object\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-To\-Data\-Object\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Data\-Set\-To\-Data\-Object\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Data\-Set\-To\-Data\-Object\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Geometry (int )} -\/ Turn on/off the conversion of dataset geometry to a data object.  
\item {\ttfamily int = obj.\-Get\-Geometry ()} -\/ Turn on/off the conversion of dataset geometry to a data object.  
\item {\ttfamily obj.\-Geometry\-On ()} -\/ Turn on/off the conversion of dataset geometry to a data object.  
\item {\ttfamily obj.\-Geometry\-Off ()} -\/ Turn on/off the conversion of dataset geometry to a data object.  
\item {\ttfamily obj.\-Set\-Topology (int )} -\/ Turn on/off the conversion of dataset topology to a data object.  
\item {\ttfamily int = obj.\-Get\-Topology ()} -\/ Turn on/off the conversion of dataset topology to a data object.  
\item {\ttfamily obj.\-Topology\-On ()} -\/ Turn on/off the conversion of dataset topology to a data object.  
\item {\ttfamily obj.\-Topology\-Off ()} -\/ Turn on/off the conversion of dataset topology to a data object.  
\item {\ttfamily obj.\-Set\-Field\-Data (int )} -\/ Turn on/off the conversion of dataset field data to a data object.  
\item {\ttfamily int = obj.\-Get\-Field\-Data ()} -\/ Turn on/off the conversion of dataset field data to a data object.  
\item {\ttfamily obj.\-Field\-Data\-On ()} -\/ Turn on/off the conversion of dataset field data to a data object.  
\item {\ttfamily obj.\-Field\-Data\-Off ()} -\/ Turn on/off the conversion of dataset field data to a data object.  
\item {\ttfamily obj.\-Set\-Point\-Data (int )} -\/ Turn on/off the conversion of dataset point data to a data object.  
\item {\ttfamily int = obj.\-Get\-Point\-Data ()} -\/ Turn on/off the conversion of dataset point data to a data object.  
\item {\ttfamily obj.\-Point\-Data\-On ()} -\/ Turn on/off the conversion of dataset point data to a data object.  
\item {\ttfamily obj.\-Point\-Data\-Off ()} -\/ Turn on/off the conversion of dataset point data to a data object.  
\item {\ttfamily obj.\-Set\-Cell\-Data (int )} -\/ Turn on/off the conversion of dataset cell data to a data object.  
\item {\ttfamily int = obj.\-Get\-Cell\-Data ()} -\/ Turn on/off the conversion of dataset cell data to a data object.  
\item {\ttfamily obj.\-Cell\-Data\-On ()} -\/ Turn on/off the conversion of dataset cell data to a data object.  
\item {\ttfamily obj.\-Cell\-Data\-Off ()} -\/ Turn on/off the conversion of dataset cell data to a data object.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkdatasettrianglefilter}{}\section{vtk\-Data\-Set\-Triangle\-Filter}\label{vtkgraphics_vtkdatasettrianglefilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Data\-Set\-Triangle\-Filter generates n-\/dimensional simplices from any input dataset. That is, 3\-D cells are converted to tetrahedral meshes, 2\-D cells to triangles, and so on. The triangulation is guaranteed to be compatible.

This filter uses simple 1\-D and 2\-D triangulation techniques for cells that are of topological dimension 2 or less. For 3\-D cells--due to the issue of face compatibility across quadrilateral faces (which way to orient the diagonal?)--a fancier ordered Delaunay triangulation is used. This approach produces templates on the fly for triangulating the cells. The templates are then used to do the actual triangulation.

To create an instance of class vtk\-Data\-Set\-Triangle\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDataSetTriangleFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Data\-Set\-Triangle\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Triangle\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Data\-Set\-Triangle\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Data\-Set\-Triangle\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Tetrahedra\-Only (int )} -\/ When On this filter will cull all 1\-D and 2\-D cells from the output. The default is Off.  
\item {\ttfamily int = obj.\-Get\-Tetrahedra\-Only ()} -\/ When On this filter will cull all 1\-D and 2\-D cells from the output. The default is Off.  
\item {\ttfamily obj.\-Tetrahedra\-Only\-On ()} -\/ When On this filter will cull all 1\-D and 2\-D cells from the output. The default is Off.  
\item {\ttfamily obj.\-Tetrahedra\-Only\-Off ()} -\/ When On this filter will cull all 1\-D and 2\-D cells from the output. The default is Off.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkdecimatepolylinefilter}{}\section{vtk\-Decimate\-Polyline\-Filter}\label{vtkgraphics_vtkdecimatepolylinefilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Decimate\-Polyline\-Filter is a filter to reduce the number of lines in a polyline. The algorithm functions by evaluating an error metric for each vertex (i.\-e., the distance of the vertex to a line defined from the two vertices on either side of the vertex). Then, these vertices are placed into a priority queue, and those with larger errors are deleted first. The decimation continues until the target reduction is reached.

To create an instance of class vtk\-Decimate\-Polyline\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDecimatePolylineFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Decimate\-Polyline\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Decimate\-Polyline\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for type information and printing.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for type information and printing.  
\item {\ttfamily vtk\-Decimate\-Polyline\-Filter = obj.\-New\-Instance ()} -\/ Standard methods for type information and printing.  
\item {\ttfamily vtk\-Decimate\-Polyline\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for type information and printing.  
\item {\ttfamily obj.\-Set\-Target\-Reduction (double )} -\/ Specify the desired reduction in the total number of polygons (e.\-g., if Target\-Reduction is set to 0.\-9, this filter will try to reduce the data set to 10\% of its original size).  
\item {\ttfamily double = obj.\-Get\-Target\-Reduction\-Min\-Value ()} -\/ Specify the desired reduction in the total number of polygons (e.\-g., if Target\-Reduction is set to 0.\-9, this filter will try to reduce the data set to 10\% of its original size).  
\item {\ttfamily double = obj.\-Get\-Target\-Reduction\-Max\-Value ()} -\/ Specify the desired reduction in the total number of polygons (e.\-g., if Target\-Reduction is set to 0.\-9, this filter will try to reduce the data set to 10\% of its original size).  
\item {\ttfamily double = obj.\-Get\-Target\-Reduction ()} -\/ Specify the desired reduction in the total number of polygons (e.\-g., if Target\-Reduction is set to 0.\-9, this filter will try to reduce the data set to 10\% of its original size).  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkdecimatepro}{}\section{vtk\-Decimate\-Pro}\label{vtkgraphics_vtkdecimatepro}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Decimate\-Pro is a filter to reduce the number of triangles in a triangle mesh, forming a good approximation to the original geometry. The input to vtk\-Decimate\-Pro is a vtk\-Poly\-Data object, and only triangles are treated. If you desire to decimate polygonal meshes, first triangulate the polygons with vtk\-Triangle\-Filter object.

The implementation of vtk\-Decimate\-Pro is similar to the algorithm originally described in \char`\"{}\-Decimation of Triangle Meshes\char`\"{}, Proc Siggraph `92, with three major differences. First, this algorithm does not necessarily preserve the topology of the mesh. Second, it is guaranteed to give the a mesh reduction factor specified by the user (as long as certain constraints are not set -\/ see Caveats). Third, it is set up generate progressive meshes, that is a stream of operations that can be easily transmitted and incrementally updated (see Hugues Hoppe's Siggraph '96 paper on progressive meshes).

The algorithm proceeds as follows. Each vertex in the mesh is classified and inserted into a priority queue. The priority is based on the error to delete the vertex and retriangulate the hole. Vertices that cannot be deleted or triangulated (at this point in the algorithm) are skipped. Then, each vertex in the priority queue is processed (i.\-e., deleted followed by hole triangulation using edge collapse). This continues until the priority queue is empty. Next, all remaining vertices are processed, and the mesh is split into separate pieces along sharp edges or at non-\/manifold attachment points and reinserted into the priority queue. Again, the priority queue is processed until empty. If the desired reduction is still not achieved, the remaining vertices are split as necessary (in a recursive fashion) so that it is possible to eliminate every triangle as necessary.

To use this object, at a minimum you need to specify the ivar Target\-Reduction. The algorithm is guaranteed to generate a reduced mesh at this level as long as the following four conditions are met\-: 1) topology modification is allowed (i.\-e., the ivar Preserve\-Topology is off); 2) mesh splitting is enabled (i.\-e., the ivar Splitting is on); 3) the algorithm is allowed to modify the boundary of the mesh (i.\-e., the ivar Boundary\-Vertex\-Deletion is on); and 4) the maximum allowable error (i.\-e., the ivar Maximum\-Error) is set to V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E\-\_\-\-M\-A\-X. Other important parameters to adjust include the Feature\-Angle and Split\-Angle ivars, since these can impact the quality of the final mesh. Also, you can set the ivar Accumulate\-Error to force incremental error update and distribution to surrounding vertices as each vertex is deleted. The accumulated error is a conservative global error bounds and decimation error, but requires additional memory and time to compute.

To create an instance of class vtk\-Decimate\-Pro, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDecimatePro
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Decimate\-Pro has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Decimate\-Pro class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Decimate\-Pro = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Decimate\-Pro = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Target\-Reduction (double )} -\/ Specify the desired reduction in the total number of polygons (e.\-g., if Target\-Reduction is set to 0.\-9, this filter will try to reduce the data set to 10\% of its original size). Because of various constraints, this level of reduction may not be realized. If you want to guarantee a particular reduction, you must turn off Preserve\-Topology, turn on Split\-Edges and Boundary\-Vertex\-Deletion, and set the Maximum\-Error to V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E\-\_\-\-M\-A\-X (these ivars are initialized this way when the object is instantiated).  
\item {\ttfamily double = obj.\-Get\-Target\-Reduction\-Min\-Value ()} -\/ Specify the desired reduction in the total number of polygons (e.\-g., if Target\-Reduction is set to 0.\-9, this filter will try to reduce the data set to 10\% of its original size). Because of various constraints, this level of reduction may not be realized. If you want to guarantee a particular reduction, you must turn off Preserve\-Topology, turn on Split\-Edges and Boundary\-Vertex\-Deletion, and set the Maximum\-Error to V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E\-\_\-\-M\-A\-X (these ivars are initialized this way when the object is instantiated).  
\item {\ttfamily double = obj.\-Get\-Target\-Reduction\-Max\-Value ()} -\/ Specify the desired reduction in the total number of polygons (e.\-g., if Target\-Reduction is set to 0.\-9, this filter will try to reduce the data set to 10\% of its original size). Because of various constraints, this level of reduction may not be realized. If you want to guarantee a particular reduction, you must turn off Preserve\-Topology, turn on Split\-Edges and Boundary\-Vertex\-Deletion, and set the Maximum\-Error to V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E\-\_\-\-M\-A\-X (these ivars are initialized this way when the object is instantiated).  
\item {\ttfamily double = obj.\-Get\-Target\-Reduction ()} -\/ Specify the desired reduction in the total number of polygons (e.\-g., if Target\-Reduction is set to 0.\-9, this filter will try to reduce the data set to 10\% of its original size). Because of various constraints, this level of reduction may not be realized. If you want to guarantee a particular reduction, you must turn off Preserve\-Topology, turn on Split\-Edges and Boundary\-Vertex\-Deletion, and set the Maximum\-Error to V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E\-\_\-\-M\-A\-X (these ivars are initialized this way when the object is instantiated).  
\item {\ttfamily obj.\-Set\-Preserve\-Topology (int )} -\/ Turn on/off whether to preserve the topology of the original mesh. If on, mesh splitting and hole elimination will not occur. This may limit the maximum reduction that may be achieved.  
\item {\ttfamily int = obj.\-Get\-Preserve\-Topology ()} -\/ Turn on/off whether to preserve the topology of the original mesh. If on, mesh splitting and hole elimination will not occur. This may limit the maximum reduction that may be achieved.  
\item {\ttfamily obj.\-Preserve\-Topology\-On ()} -\/ Turn on/off whether to preserve the topology of the original mesh. If on, mesh splitting and hole elimination will not occur. This may limit the maximum reduction that may be achieved.  
\item {\ttfamily obj.\-Preserve\-Topology\-Off ()} -\/ Turn on/off whether to preserve the topology of the original mesh. If on, mesh splitting and hole elimination will not occur. This may limit the maximum reduction that may be achieved.  
\item {\ttfamily obj.\-Set\-Feature\-Angle (double )} -\/ Specify the mesh feature angle. This angle is used to define what an edge is (i.\-e., if the surface normal between two adjacent triangles is $>$= Feature\-Angle, an edge exists).  
\item {\ttfamily double = obj.\-Get\-Feature\-Angle\-Min\-Value ()} -\/ Specify the mesh feature angle. This angle is used to define what an edge is (i.\-e., if the surface normal between two adjacent triangles is $>$= Feature\-Angle, an edge exists).  
\item {\ttfamily double = obj.\-Get\-Feature\-Angle\-Max\-Value ()} -\/ Specify the mesh feature angle. This angle is used to define what an edge is (i.\-e., if the surface normal between two adjacent triangles is $>$= Feature\-Angle, an edge exists).  
\item {\ttfamily double = obj.\-Get\-Feature\-Angle ()} -\/ Specify the mesh feature angle. This angle is used to define what an edge is (i.\-e., if the surface normal between two adjacent triangles is $>$= Feature\-Angle, an edge exists).  
\item {\ttfamily obj.\-Set\-Splitting (int )} -\/ Turn on/off the splitting of the mesh at corners, along edges, at non-\/manifold points, or anywhere else a split is required. Turning splitting off will better preserve the original topology of the mesh, but you may not obtain the requested reduction.  
\item {\ttfamily int = obj.\-Get\-Splitting ()} -\/ Turn on/off the splitting of the mesh at corners, along edges, at non-\/manifold points, or anywhere else a split is required. Turning splitting off will better preserve the original topology of the mesh, but you may not obtain the requested reduction.  
\item {\ttfamily obj.\-Splitting\-On ()} -\/ Turn on/off the splitting of the mesh at corners, along edges, at non-\/manifold points, or anywhere else a split is required. Turning splitting off will better preserve the original topology of the mesh, but you may not obtain the requested reduction.  
\item {\ttfamily obj.\-Splitting\-Off ()} -\/ Turn on/off the splitting of the mesh at corners, along edges, at non-\/manifold points, or anywhere else a split is required. Turning splitting off will better preserve the original topology of the mesh, but you may not obtain the requested reduction.  
\item {\ttfamily obj.\-Set\-Split\-Angle (double )} -\/ Specify the mesh split angle. This angle is used to control the splitting of the mesh. A split line exists when the surface normals between two edge connected triangles are $>$= Split\-Angle.  
\item {\ttfamily double = obj.\-Get\-Split\-Angle\-Min\-Value ()} -\/ Specify the mesh split angle. This angle is used to control the splitting of the mesh. A split line exists when the surface normals between two edge connected triangles are $>$= Split\-Angle.  
\item {\ttfamily double = obj.\-Get\-Split\-Angle\-Max\-Value ()} -\/ Specify the mesh split angle. This angle is used to control the splitting of the mesh. A split line exists when the surface normals between two edge connected triangles are $>$= Split\-Angle.  
\item {\ttfamily double = obj.\-Get\-Split\-Angle ()} -\/ Specify the mesh split angle. This angle is used to control the splitting of the mesh. A split line exists when the surface normals between two edge connected triangles are $>$= Split\-Angle.  
\item {\ttfamily obj.\-Set\-Pre\-Split\-Mesh (int )} -\/ In some cases you may wish to split the mesh prior to algorithm execution. This separates the mesh into semi-\/planar patches, which are disconnected from each other. This can give superior results in some cases. If the ivar Pre\-Split\-Mesh ivar is enabled, the mesh is split with the specified Split\-Angle. Otherwise mesh splitting is deferred as long as possible.  
\item {\ttfamily int = obj.\-Get\-Pre\-Split\-Mesh ()} -\/ In some cases you may wish to split the mesh prior to algorithm execution. This separates the mesh into semi-\/planar patches, which are disconnected from each other. This can give superior results in some cases. If the ivar Pre\-Split\-Mesh ivar is enabled, the mesh is split with the specified Split\-Angle. Otherwise mesh splitting is deferred as long as possible.  
\item {\ttfamily obj.\-Pre\-Split\-Mesh\-On ()} -\/ In some cases you may wish to split the mesh prior to algorithm execution. This separates the mesh into semi-\/planar patches, which are disconnected from each other. This can give superior results in some cases. If the ivar Pre\-Split\-Mesh ivar is enabled, the mesh is split with the specified Split\-Angle. Otherwise mesh splitting is deferred as long as possible.  
\item {\ttfamily obj.\-Pre\-Split\-Mesh\-Off ()} -\/ In some cases you may wish to split the mesh prior to algorithm execution. This separates the mesh into semi-\/planar patches, which are disconnected from each other. This can give superior results in some cases. If the ivar Pre\-Split\-Mesh ivar is enabled, the mesh is split with the specified Split\-Angle. Otherwise mesh splitting is deferred as long as possible.  
\item {\ttfamily obj.\-Set\-Maximum\-Error (double )} -\/ Set the largest decimation error that is allowed during the decimation process. This may limit the maximum reduction that may be achieved. The maximum error is specified as a fraction of the maximum length of the input data bounding box.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Error\-Min\-Value ()} -\/ Set the largest decimation error that is allowed during the decimation process. This may limit the maximum reduction that may be achieved. The maximum error is specified as a fraction of the maximum length of the input data bounding box.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Error\-Max\-Value ()} -\/ Set the largest decimation error that is allowed during the decimation process. This may limit the maximum reduction that may be achieved. The maximum error is specified as a fraction of the maximum length of the input data bounding box.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Error ()} -\/ Set the largest decimation error that is allowed during the decimation process. This may limit the maximum reduction that may be achieved. The maximum error is specified as a fraction of the maximum length of the input data bounding box.  
\item {\ttfamily obj.\-Set\-Accumulate\-Error (int )} -\/ The computed error can either be computed directly from the mesh or the error may be accumulated as the mesh is modified. If the error is accumulated, then it represents a global error bounds, and the ivar Maximum\-Error becomes a global bounds on mesh error. Accumulating the error requires extra memory proportional to the number of vertices in the mesh. If Accumulate\-Error is off, then the error is not accumulated.  
\item {\ttfamily int = obj.\-Get\-Accumulate\-Error ()} -\/ The computed error can either be computed directly from the mesh or the error may be accumulated as the mesh is modified. If the error is accumulated, then it represents a global error bounds, and the ivar Maximum\-Error becomes a global bounds on mesh error. Accumulating the error requires extra memory proportional to the number of vertices in the mesh. If Accumulate\-Error is off, then the error is not accumulated.  
\item {\ttfamily obj.\-Accumulate\-Error\-On ()} -\/ The computed error can either be computed directly from the mesh or the error may be accumulated as the mesh is modified. If the error is accumulated, then it represents a global error bounds, and the ivar Maximum\-Error becomes a global bounds on mesh error. Accumulating the error requires extra memory proportional to the number of vertices in the mesh. If Accumulate\-Error is off, then the error is not accumulated.  
\item {\ttfamily obj.\-Accumulate\-Error\-Off ()} -\/ The computed error can either be computed directly from the mesh or the error may be accumulated as the mesh is modified. If the error is accumulated, then it represents a global error bounds, and the ivar Maximum\-Error becomes a global bounds on mesh error. Accumulating the error requires extra memory proportional to the number of vertices in the mesh. If Accumulate\-Error is off, then the error is not accumulated.  
\item {\ttfamily obj.\-Set\-Error\-Is\-Absolute (int )} -\/ The Maximum\-Error is normally defined as a fraction of the dataset bounding diagonal. By setting Error\-Is\-Absolute to 1, the error is instead defined as that specified by Absolute\-Error. By default Error\-Is\-Absolute=0.  
\item {\ttfamily int = obj.\-Get\-Error\-Is\-Absolute ()} -\/ The Maximum\-Error is normally defined as a fraction of the dataset bounding diagonal. By setting Error\-Is\-Absolute to 1, the error is instead defined as that specified by Absolute\-Error. By default Error\-Is\-Absolute=0.  
\item {\ttfamily obj.\-Set\-Absolute\-Error (double )} -\/ Same as Maximum\-Error, but to be used when Error\-Is\-Absolute is 1  
\item {\ttfamily double = obj.\-Get\-Absolute\-Error\-Min\-Value ()} -\/ Same as Maximum\-Error, but to be used when Error\-Is\-Absolute is 1  
\item {\ttfamily double = obj.\-Get\-Absolute\-Error\-Max\-Value ()} -\/ Same as Maximum\-Error, but to be used when Error\-Is\-Absolute is 1  
\item {\ttfamily double = obj.\-Get\-Absolute\-Error ()} -\/ Same as Maximum\-Error, but to be used when Error\-Is\-Absolute is 1  
\item {\ttfamily obj.\-Set\-Boundary\-Vertex\-Deletion (int )} -\/ Turn on/off the deletion of vertices on the boundary of a mesh. This may limit the maximum reduction that may be achieved.  
\item {\ttfamily int = obj.\-Get\-Boundary\-Vertex\-Deletion ()} -\/ Turn on/off the deletion of vertices on the boundary of a mesh. This may limit the maximum reduction that may be achieved.  
\item {\ttfamily obj.\-Boundary\-Vertex\-Deletion\-On ()} -\/ Turn on/off the deletion of vertices on the boundary of a mesh. This may limit the maximum reduction that may be achieved.  
\item {\ttfamily obj.\-Boundary\-Vertex\-Deletion\-Off ()} -\/ Turn on/off the deletion of vertices on the boundary of a mesh. This may limit the maximum reduction that may be achieved.  
\item {\ttfamily obj.\-Set\-Degree (int )} -\/ If the number of triangles connected to a vertex exceeds \char`\"{}\-Degree\char`\"{}, then the vertex will be split. (N\-O\-T\-E\-: the complexity of the triangulation algorithm is proportional to Degree$^\wedge$2. Setting degree small can improve the performance of the algorithm.)  
\item {\ttfamily int = obj.\-Get\-Degree\-Min\-Value ()} -\/ If the number of triangles connected to a vertex exceeds \char`\"{}\-Degree\char`\"{}, then the vertex will be split. (N\-O\-T\-E\-: the complexity of the triangulation algorithm is proportional to Degree$^\wedge$2. Setting degree small can improve the performance of the algorithm.)  
\item {\ttfamily int = obj.\-Get\-Degree\-Max\-Value ()} -\/ If the number of triangles connected to a vertex exceeds \char`\"{}\-Degree\char`\"{}, then the vertex will be split. (N\-O\-T\-E\-: the complexity of the triangulation algorithm is proportional to Degree$^\wedge$2. Setting degree small can improve the performance of the algorithm.)  
\item {\ttfamily int = obj.\-Get\-Degree ()} -\/ If the number of triangles connected to a vertex exceeds \char`\"{}\-Degree\char`\"{}, then the vertex will be split. (N\-O\-T\-E\-: the complexity of the triangulation algorithm is proportional to Degree$^\wedge$2. Setting degree small can improve the performance of the algorithm.)  
\item {\ttfamily obj.\-Set\-Inflection\-Point\-Ratio (double )} -\/ Specify the inflection point ratio. An inflection point occurs when the ratio of reduction error between two iterations is greater than or equal to the Inflection\-Point\-Ratio.  
\item {\ttfamily double = obj.\-Get\-Inflection\-Point\-Ratio\-Min\-Value ()} -\/ Specify the inflection point ratio. An inflection point occurs when the ratio of reduction error between two iterations is greater than or equal to the Inflection\-Point\-Ratio.  
\item {\ttfamily double = obj.\-Get\-Inflection\-Point\-Ratio\-Max\-Value ()} -\/ Specify the inflection point ratio. An inflection point occurs when the ratio of reduction error between two iterations is greater than or equal to the Inflection\-Point\-Ratio.  
\item {\ttfamily double = obj.\-Get\-Inflection\-Point\-Ratio ()} -\/ Specify the inflection point ratio. An inflection point occurs when the ratio of reduction error between two iterations is greater than or equal to the Inflection\-Point\-Ratio.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Inflection\-Points ()} -\/ Get the number of inflection points. Only returns a valid value after the filter has executed. The values in the list are mesh reduction values at each inflection point. Note\-: the first inflection point always occurs right before non-\/planar triangles are decimated (i.\-e., as the error becomes non-\/zero).  
\item {\ttfamily obj.\-Get\-Inflection\-Points (double inflection\-Points)} -\/ Get a list of inflection points. These are double values 0 $<$ r $<$= 1.\-0 corresponding to reduction level, and there are a total of Number\-Of\-Inflection\-Points() values. You must provide an array (of the correct size) into which the inflection points are written.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkdelaunay2d}{}\section{vtk\-Delaunay2\-D}\label{vtkgraphics_vtkdelaunay2d}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Delaunay2\-D is a filter that constructs a 2\-D Delaunay triangulation from a list of input points. These points may be represented by any dataset of type vtk\-Point\-Set and subclasses. The output of the filter is a polygonal dataset. Usually the output is a triangle mesh, but if a non-\/zero alpha distance value is specified (called the \char`\"{}alpha\char`\"{} value), then only triangles, edges, and vertices lying within the alpha radius are output. In other words, non-\/zero alpha values may result in arbitrary combinations of triangles, lines, and vertices. (The notion of alpha value is derived from Edelsbrunner's work on \char`\"{}alpha shapes\char`\"{}.) Also, it is possible to generate \char`\"{}constrained triangulations\char`\"{} using this filter. A constrained triangulation is one where edges and loops (i.\-e., polygons) can be defined and the triangulation will preserve them (read on for more information).

The 2\-D Delaunay triangulation is defined as the triangulation that satisfies the Delaunay criterion for n-\/dimensional simplexes (in this case n=2 and the simplexes are triangles). This criterion states that a circumsphere of each simplex in a triangulation contains only the n+1 defining points of the simplex. (See \char`\"{}\-The Visualization Toolkit\char`\"{} text for more information.) In two dimensions, this translates into an optimal triangulation. That is, the maximum interior angle of any triangle is less than or equal to that of any possible triangulation.

Delaunay triangulations are used to build topological structures from unorganized (or unstructured) points. The input to this filter is a list of points specified in 3\-D, even though the triangulation is 2\-D. Thus the triangulation is constructed in the x-\/y plane, and the z coordinate is ignored (although carried through to the output). If you desire to triangulate in a different plane, you can use the vtk\-Transform\-Filter to transform the points into and out of the x-\/y plane or you can specify a transform to the Delaunay2\-D directly. In the latter case, the input points are transformed, the transformed points are triangulated, and the output will use the triangulated topology for the original (non-\/transformed) points. This avoids transforming the data back as would be required when using the vtk\-Transform\-Filter method. Specifying a transform directly also allows any transform to be used\-: rigid, non-\/rigid, non-\/invertible, etc.

If an input transform is used, then alpha values are applied (for the most part) in the original data space. The exception is when Bounding\-Triangulation is on. In this case, alpha values are applied in the original data space unless a cell uses a bounding vertex.

The Delaunay triangulation can be numerically sensitive in some cases. To prevent problems, try to avoid injecting points that will result in triangles with bad aspect ratios (1000\-:1 or greater). In practice this means inserting points that are \char`\"{}widely dispersed\char`\"{}, and enables smooth transition of triangle sizes throughout the mesh. (You may even want to add extra points to create a better point distribution.) If numerical problems are present, you will see a warning message to this effect at the end of the triangulation process.

To create constrained meshes, you must define an additional input. This input is an instance of vtk\-Poly\-Data which contains lines, polylines, and/or polygons that define constrained edges and loops. Only the topology of (lines and polygons) from this second input are used. The topology is assumed to reference points in the input point set (the one to be triangulated). In other words, the lines and polygons use point ids from the first input point set. Lines and polylines found in the input will be mesh edges in the output. Polygons define a loop with inside and outside regions. The inside of the polygon is determined by using the right-\/hand-\/rule, i.\-e., looking down the z-\/axis a polygon should be ordered counter-\/clockwise. Holes in a polygon should be ordered clockwise. If you choose to create a constrained triangulation, the final mesh may not satisfy the Delaunay criterion. (Noted\-: the lines/polygon edges must not intersect when projected onto the 2\-D plane. It may not be possible to recover all edges due to not enough points in the triangulation, or poorly defined edges (coincident or excessively long). The form of the lines or polygons is a list of point ids that correspond to the input point ids used to generate the triangulation.)

If an input transform is used, constraints are defined in the \char`\"{}transformed\char`\"{} space. So when the right hand rule is used for a polygon constraint, that operation is applied using the transformed points. Since the input transform can be any transformation (rigid or non-\/rigid), care must be taken in constructing constraints when an input transform is used.

To create an instance of class vtk\-Delaunay2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDelaunay2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Delaunay2\-D has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Delaunay2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Delaunay2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Delaunay2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Source (vtk\-Poly\-Data )} -\/ Specify the source object used to specify constrained edges and loops. (This is optional.) If set, and lines/polygons are defined, a constrained triangulation is created. The lines/polygons are assumed to reference points in the input point set (i.\-e. point ids are identical in the input and source). Old style. See Set\-Source\-Connection.  
\item {\ttfamily obj.\-Set\-Source\-Connection (vtk\-Algorithm\-Output alg\-Output)} -\/ Specify the source object used to specify constrained edges and loops. (This is optional.) If set, and lines/polygons are defined, a constrained triangulation is created. The lines/polygons are assumed to reference points in the input point set (i.\-e. point ids are identical in the input and source). New style. This method is equivalent to Set\-Input\-Connection(1, alg\-Output).  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Source ()} -\/ Get a pointer to the source object.  
\item {\ttfamily obj.\-Set\-Alpha (double )} -\/ Specify alpha (or distance) value to control output of this filter. For a non-\/zero alpha value, only edges or triangles contained within a sphere centered at mesh vertices will be output. Otherwise, only triangles will be output.  
\item {\ttfamily double = obj.\-Get\-Alpha\-Min\-Value ()} -\/ Specify alpha (or distance) value to control output of this filter. For a non-\/zero alpha value, only edges or triangles contained within a sphere centered at mesh vertices will be output. Otherwise, only triangles will be output.  
\item {\ttfamily double = obj.\-Get\-Alpha\-Max\-Value ()} -\/ Specify alpha (or distance) value to control output of this filter. For a non-\/zero alpha value, only edges or triangles contained within a sphere centered at mesh vertices will be output. Otherwise, only triangles will be output.  
\item {\ttfamily double = obj.\-Get\-Alpha ()} -\/ Specify alpha (or distance) value to control output of this filter. For a non-\/zero alpha value, only edges or triangles contained within a sphere centered at mesh vertices will be output. Otherwise, only triangles will be output.  
\item {\ttfamily obj.\-Set\-Tolerance (double )} -\/ Specify a tolerance to control discarding of closely spaced points. This tolerance is specified as a fraction of the diagonal length of the bounding box of the points.  
\item {\ttfamily double = obj.\-Get\-Tolerance\-Min\-Value ()} -\/ Specify a tolerance to control discarding of closely spaced points. This tolerance is specified as a fraction of the diagonal length of the bounding box of the points.  
\item {\ttfamily double = obj.\-Get\-Tolerance\-Max\-Value ()} -\/ Specify a tolerance to control discarding of closely spaced points. This tolerance is specified as a fraction of the diagonal length of the bounding box of the points.  
\item {\ttfamily double = obj.\-Get\-Tolerance ()} -\/ Specify a tolerance to control discarding of closely spaced points. This tolerance is specified as a fraction of the diagonal length of the bounding box of the points.  
\item {\ttfamily obj.\-Set\-Offset (double )} -\/ Specify a multiplier to control the size of the initial, bounding Delaunay triangulation.  
\item {\ttfamily double = obj.\-Get\-Offset\-Min\-Value ()} -\/ Specify a multiplier to control the size of the initial, bounding Delaunay triangulation.  
\item {\ttfamily double = obj.\-Get\-Offset\-Max\-Value ()} -\/ Specify a multiplier to control the size of the initial, bounding Delaunay triangulation.  
\item {\ttfamily double = obj.\-Get\-Offset ()} -\/ Specify a multiplier to control the size of the initial, bounding Delaunay triangulation.  
\item {\ttfamily obj.\-Set\-Bounding\-Triangulation (int )} -\/ Boolean controls whether bounding triangulation points (and associated triangles) are included in the output. (These are introduced as an initial triangulation to begin the triangulation process. This feature is nice for debugging output.)  
\item {\ttfamily int = obj.\-Get\-Bounding\-Triangulation ()} -\/ Boolean controls whether bounding triangulation points (and associated triangles) are included in the output. (These are introduced as an initial triangulation to begin the triangulation process. This feature is nice for debugging output.)  
\item {\ttfamily obj.\-Bounding\-Triangulation\-On ()} -\/ Boolean controls whether bounding triangulation points (and associated triangles) are included in the output. (These are introduced as an initial triangulation to begin the triangulation process. This feature is nice for debugging output.)  
\item {\ttfamily obj.\-Bounding\-Triangulation\-Off ()} -\/ Boolean controls whether bounding triangulation points (and associated triangles) are included in the output. (These are introduced as an initial triangulation to begin the triangulation process. This feature is nice for debugging output.)  
\item {\ttfamily obj.\-Set\-Transform (vtk\-Abstract\-Transform )} -\/ Set / get the transform which is applied to points to generate a 2\-D problem. This maps a 3\-D dataset into a 2\-D dataset where triangulation can be done on the X\-Y plane. The points are transformed and triangulated. The topology of triangulated points is used as the output topology. The output points are the original (untransformed) points. The transform can be any subclass of vtk\-Abstract\-Transform (thus it does not need to be a linear or invertible transform).  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Get\-Transform ()} -\/ Set / get the transform which is applied to points to generate a 2\-D problem. This maps a 3\-D dataset into a 2\-D dataset where triangulation can be done on the X\-Y plane. The points are transformed and triangulated. The topology of triangulated points is used as the output topology. The output points are the original (untransformed) points. The transform can be any subclass of vtk\-Abstract\-Transform (thus it does not need to be a linear or invertible transform).  
\item {\ttfamily obj.\-Set\-Projection\-Plane\-Mode (int )} -\/ Define  
\item {\ttfamily int = obj.\-Get\-Projection\-Plane\-Mode\-Min\-Value ()} -\/ Define  
\item {\ttfamily int = obj.\-Get\-Projection\-Plane\-Mode\-Max\-Value ()} -\/ Define  
\item {\ttfamily int = obj.\-Get\-Projection\-Plane\-Mode ()} -\/ Define  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkdelaunay3d}{}\section{vtk\-Delaunay3\-D}\label{vtkgraphics_vtkdelaunay3d}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Delaunay3\-D is a filter that constructs a 3\-D Delaunay triangulation from a list of input points. These points may be represented by any dataset of type vtk\-Point\-Set and subclasses. The output of the filter is an unstructured grid dataset. Usually the output is a tetrahedral mesh, but if a non-\/zero alpha distance value is specified (called the \char`\"{}alpha\char`\"{} value), then only tetrahedra, triangles, edges, and vertices lying within the alpha radius are output. In other words, non-\/zero alpha values may result in arbitrary combinations of tetrahedra, triangles, lines, and vertices. (The notion of alpha value is derived from Edelsbrunner's work on \char`\"{}alpha shapes\char`\"{}.)

The 3\-D Delaunay triangulation is defined as the triangulation that satisfies the Delaunay criterion for n-\/dimensional simplexes (in this case n=3 and the simplexes are tetrahedra). This criterion states that a circumsphere of each simplex in a triangulation contains only the n+1 defining points of the simplex. (See text for more information.) While in two dimensions this translates into an \char`\"{}optimal\char`\"{} triangulation, this is not true in 3\-D, since a measurement for optimality in 3\-D is not agreed on.

Delaunay triangulations are used to build topological structures from unorganized (or unstructured) points. The input to this filter is a list of points specified in 3\-D. (If you wish to create 2\-D triangulations see vtk\-Delaunay2\-D.) The output is an unstructured grid.

The Delaunay triangulation can be numerically sensitive. To prevent problems, try to avoid injecting points that will result in triangles with bad aspect ratios (1000\-:1 or greater). In practice this means inserting points that are \char`\"{}widely dispersed\char`\"{}, and enables smooth transition of triangle sizes throughout the mesh. (You may even want to add extra points to create a better point distribution.) If numerical problems are present, you will see a warning message to this effect at the end of the triangulation process.

To create an instance of class vtk\-Delaunay3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDelaunay3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Delaunay3\-D has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Delaunay3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Delaunay3\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Delaunay3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Alpha (double )} -\/ Specify alpha (or distance) value to control output of this filter. For a non-\/zero alpha value, only edges, faces, or tetra contained within the circumsphere (of radius alpha) will be output. Otherwise, only tetrahedra will be output.  
\item {\ttfamily double = obj.\-Get\-Alpha\-Min\-Value ()} -\/ Specify alpha (or distance) value to control output of this filter. For a non-\/zero alpha value, only edges, faces, or tetra contained within the circumsphere (of radius alpha) will be output. Otherwise, only tetrahedra will be output.  
\item {\ttfamily double = obj.\-Get\-Alpha\-Max\-Value ()} -\/ Specify alpha (or distance) value to control output of this filter. For a non-\/zero alpha value, only edges, faces, or tetra contained within the circumsphere (of radius alpha) will be output. Otherwise, only tetrahedra will be output.  
\item {\ttfamily double = obj.\-Get\-Alpha ()} -\/ Specify alpha (or distance) value to control output of this filter. For a non-\/zero alpha value, only edges, faces, or tetra contained within the circumsphere (of radius alpha) will be output. Otherwise, only tetrahedra will be output.  
\item {\ttfamily obj.\-Set\-Tolerance (double )} -\/ Specify a tolerance to control discarding of closely spaced points. This tolerance is specified as a fraction of the diagonal length of the bounding box of the points.  
\item {\ttfamily double = obj.\-Get\-Tolerance\-Min\-Value ()} -\/ Specify a tolerance to control discarding of closely spaced points. This tolerance is specified as a fraction of the diagonal length of the bounding box of the points.  
\item {\ttfamily double = obj.\-Get\-Tolerance\-Max\-Value ()} -\/ Specify a tolerance to control discarding of closely spaced points. This tolerance is specified as a fraction of the diagonal length of the bounding box of the points.  
\item {\ttfamily double = obj.\-Get\-Tolerance ()} -\/ Specify a tolerance to control discarding of closely spaced points. This tolerance is specified as a fraction of the diagonal length of the bounding box of the points.  
\item {\ttfamily obj.\-Set\-Offset (double )} -\/ Specify a multiplier to control the size of the initial, bounding Delaunay triangulation.  
\item {\ttfamily double = obj.\-Get\-Offset\-Min\-Value ()} -\/ Specify a multiplier to control the size of the initial, bounding Delaunay triangulation.  
\item {\ttfamily double = obj.\-Get\-Offset\-Max\-Value ()} -\/ Specify a multiplier to control the size of the initial, bounding Delaunay triangulation.  
\item {\ttfamily double = obj.\-Get\-Offset ()} -\/ Specify a multiplier to control the size of the initial, bounding Delaunay triangulation.  
\item {\ttfamily obj.\-Set\-Bounding\-Triangulation (int )} -\/ Boolean controls whether bounding triangulation points (and associated triangles) are included in the output. (These are introduced as an initial triangulation to begin the triangulation process. This feature is nice for debugging output.)  
\item {\ttfamily int = obj.\-Get\-Bounding\-Triangulation ()} -\/ Boolean controls whether bounding triangulation points (and associated triangles) are included in the output. (These are introduced as an initial triangulation to begin the triangulation process. This feature is nice for debugging output.)  
\item {\ttfamily obj.\-Bounding\-Triangulation\-On ()} -\/ Boolean controls whether bounding triangulation points (and associated triangles) are included in the output. (These are introduced as an initial triangulation to begin the triangulation process. This feature is nice for debugging output.)  
\item {\ttfamily obj.\-Bounding\-Triangulation\-Off ()} -\/ Boolean controls whether bounding triangulation points (and associated triangles) are included in the output. (These are introduced as an initial triangulation to begin the triangulation process. This feature is nice for debugging output.)  
\item {\ttfamily obj.\-Set\-Locator (vtk\-Incremental\-Point\-Locator locator)} -\/ Set / get a spatial locator for merging points. By default, an instance of vtk\-Point\-Locator 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\-Point\-Locator is used.  
\item {\ttfamily obj.\-Create\-Default\-Locator ()} -\/ Create default locator. Used to create one when none is specified. The locator is used to eliminate \char`\"{}coincident\char`\"{} points.  
\item {\ttfamily obj.\-Insert\-Point (vtk\-Unstructured\-Grid Mesh, vtk\-Points points, vtk\-Id\-Type id, double x\mbox{[}3\mbox{]}, vtk\-Id\-List hole\-Tetras)} -\/ This is a helper method used with Init\-Point\-Insertion() to create tetrahedronalizations of points. Its purpose is to inject point at coordinates specified into tetrahedronalization. The point id is an index into the list of points in the mesh structure. (See vtk\-Delaunay3\-D\-::\-Init\-Point\-Insertion() for more information.) When you have completed inserting points, traverse the mesh structure to extract desired tetrahedra (or tetra faces and edges).The hole\-Tetras id list lists all the tetrahedra that are deleted (invalid) in the mesh structure.  
\item {\ttfamily obj.\-End\-Point\-Insertion ()} -\/ Invoke this method after all points have been inserted. The purpose of the method is to clean up internal data structures. Note that the (vtk\-Unstructured\-Grid $\ast$)Mesh returned from Init\-Point\-Insertion() is N\-O\-T deleted, you still are responsible for cleaning that up.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return the M\-Time also considering the locator.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkdensifypolydata}{}\section{vtk\-Densify\-Poly\-Data}\label{vtkgraphics_vtkdensifypolydata}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The filter takes any polygonal data as input and will tessellate cells that are planar polygons present by fanning out triangles from its centroid. Other cells are simply passed through to the output. Point\-Data, if present, is interpolated via linear interpolation. Cell\-Data for any tessellated cell is simply copied over from its parent cell. Planar polygons are assumed to be convex. Funny things will happen if they are not.

The number of subdivisions can be controlled by the parameter Number\-Of\-Subdivisions.

To create an instance of class vtk\-Densify\-Poly\-Data, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDensifyPolyData
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Densify\-Poly\-Data has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Densify\-Poly\-Data class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Densify\-Poly\-Data = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Densify\-Poly\-Data = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Number\-Of\-Subdivisions (int )} -\/ Number of recursive subdivisions. Initial value is 1.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Subdivisions ()} -\/ Number of recursive subdivisions. Initial value is 1.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkdicer}{}\section{vtk\-Dicer}\label{vtkgraphics_vtkdicer}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Subclasses of vtk\-Dicer divides the input dataset into separate pieces. These pieces can then be operated on by other filters (e.\-g., vtk\-Threshold). One application is to break very large polygonal models into pieces and performing viewing and occlusion culling on the pieces. Multiple pieces can also be streamed through the visualization pipeline.

To use this filter, you must specify the execution mode of the filter; i.\-e., set the way that the piece size is controlled (do this by setting the Dice\-Mode ivar). The filter does not change the geometry or topology of the input dataset, rather it generates integer numbers that indicate which piece a particular point belongs to (i.\-e., it modifies the point and cell attribute data). The integer number can be placed into the output scalar data, or the output field data.

To create an instance of class vtk\-Dicer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDicer
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Dicer has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Dicer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Dicer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Dicer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Field\-Data (int )} -\/ Set/\-Get the flag which controls whether to generate point scalar data or point field data. If this flag is off, scalar data is generated. Otherwise, field data is generated. Note that the generated the data are integer numbers indicating which piece a particular point belongs to.  
\item {\ttfamily int = obj.\-Get\-Field\-Data ()} -\/ Set/\-Get the flag which controls whether to generate point scalar data or point field data. If this flag is off, scalar data is generated. Otherwise, field data is generated. Note that the generated the data are integer numbers indicating which piece a particular point belongs to.  
\item {\ttfamily obj.\-Field\-Data\-On ()} -\/ Set/\-Get the flag which controls whether to generate point scalar data or point field data. If this flag is off, scalar data is generated. Otherwise, field data is generated. Note that the generated the data are integer numbers indicating which piece a particular point belongs to.  
\item {\ttfamily obj.\-Field\-Data\-Off ()} -\/ Set/\-Get the flag which controls whether to generate point scalar data or point field data. If this flag is off, scalar data is generated. Otherwise, field data is generated. Note that the generated the data are integer numbers indicating which piece a particular point belongs to.  
\item {\ttfamily obj.\-Set\-Dice\-Mode (int )} -\/ Specify the method to determine how many pieces the data should be broken into. By default, the number of points per piece is used.  
\item {\ttfamily int = obj.\-Get\-Dice\-Mode\-Min\-Value ()} -\/ Specify the method to determine how many pieces the data should be broken into. By default, the number of points per piece is used.  
\item {\ttfamily int = obj.\-Get\-Dice\-Mode\-Max\-Value ()} -\/ Specify the method to determine how many pieces the data should be broken into. By default, the number of points per piece is used.  
\item {\ttfamily int = obj.\-Get\-Dice\-Mode ()} -\/ Specify the method to determine how many pieces the data should be broken into. By default, the number of points per piece is used.  
\item {\ttfamily obj.\-Set\-Dice\-Mode\-To\-Number\-Of\-Points\-Per\-Piece ()} -\/ Specify the method to determine how many pieces the data should be broken into. By default, the number of points per piece is used.  
\item {\ttfamily obj.\-Set\-Dice\-Mode\-To\-Specified\-Number\-Of\-Pieces ()} -\/ Specify the method to determine how many pieces the data should be broken into. By default, the number of points per piece is used.  
\item {\ttfamily obj.\-Set\-Dice\-Mode\-To\-Memory\-Limit\-Per\-Piece ()} -\/ Specify the method to determine how many pieces the data should be broken into. By default, the number of points per piece is used.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Actual\-Pieces ()} -\/ Use the following method after the filter has updated to determine the actual number of pieces the data was separated into.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Points\-Per\-Piece (int )} -\/ Control piece size based on the maximum number of points per piece. (This ivar has effect only when the Dice\-Mode is set to Set\-Dice\-Mode\-To\-Number\-Of\-Points().)  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Points\-Per\-Piece\-Min\-Value ()} -\/ Control piece size based on the maximum number of points per piece. (This ivar has effect only when the Dice\-Mode is set to Set\-Dice\-Mode\-To\-Number\-Of\-Points().)  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Points\-Per\-Piece\-Max\-Value ()} -\/ Control piece size based on the maximum number of points per piece. (This ivar has effect only when the Dice\-Mode is set to Set\-Dice\-Mode\-To\-Number\-Of\-Points().)  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Points\-Per\-Piece ()} -\/ Control piece size based on the maximum number of points per piece. (This ivar has effect only when the Dice\-Mode is set to Set\-Dice\-Mode\-To\-Number\-Of\-Points().)  
\item {\ttfamily obj.\-Set\-Number\-Of\-Pieces (int )} -\/ Set/\-Get the number of pieces the object is to be separated into. (This ivar has effect only when the Dice\-Mode is set to Set\-Dice\-Mode\-To\-Specified\-Number()). Note that the ivar Number\-Of\-Pieces is a target -\/ depending on the particulars of the data, more or less number of pieces than the target value may be created.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Pieces\-Min\-Value ()} -\/ Set/\-Get the number of pieces the object is to be separated into. (This ivar has effect only when the Dice\-Mode is set to Set\-Dice\-Mode\-To\-Specified\-Number()). Note that the ivar Number\-Of\-Pieces is a target -\/ depending on the particulars of the data, more or less number of pieces than the target value may be created.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Pieces\-Max\-Value ()} -\/ Set/\-Get the number of pieces the object is to be separated into. (This ivar has effect only when the Dice\-Mode is set to Set\-Dice\-Mode\-To\-Specified\-Number()). Note that the ivar Number\-Of\-Pieces is a target -\/ depending on the particulars of the data, more or less number of pieces than the target value may be created.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Pieces ()} -\/ Set/\-Get the number of pieces the object is to be separated into. (This ivar has effect only when the Dice\-Mode is set to Set\-Dice\-Mode\-To\-Specified\-Number()). Note that the ivar Number\-Of\-Pieces is a target -\/ depending on the particulars of the data, more or less number of pieces than the target value may be created.  
\item {\ttfamily obj.\-Set\-Memory\-Limit (long )} -\/ Control piece size based on a memory limit. (This ivar has effect only when the Dice\-Mode is set to Set\-Dice\-Mode\-To\-Memory\-Limit()). The memory limit should be set in kilobytes.  
\item {\ttfamily Get\-Memory\-Limit\-Min\-Value = obj.()} -\/ Control piece size based on a memory limit. (This ivar has effect only when the Dice\-Mode is set to Set\-Dice\-Mode\-To\-Memory\-Limit()). The memory limit should be set in kilobytes.  
\item {\ttfamily Get\-Memory\-Limit\-Max\-Value = obj.()} -\/ Control piece size based on a memory limit. (This ivar has effect only when the Dice\-Mode is set to Set\-Dice\-Mode\-To\-Memory\-Limit()). The memory limit should be set in kilobytes.  
\item {\ttfamily long = obj.\-Get\-Memory\-Limit ()} -\/ Control piece size based on a memory limit. (This ivar has effect only when the Dice\-Mode is set to Set\-Dice\-Mode\-To\-Memory\-Limit()). The memory limit should be set in kilobytes.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkdijkstragraphgeodesicpath}{}\section{vtk\-Dijkstra\-Graph\-Geodesic\-Path}\label{vtkgraphics_vtkdijkstragraphgeodesicpath}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Takes as input a polygonal mesh and performs a single source shortest path calculation. Dijkstra's algorithm is used. The implementation is similar to the one described in Introduction to Algorithms (Second Edition) by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Cliff Stein, published by M\-I\-T Press and Mc\-Graw-\/\-Hill. Some minor enhancement are added though. All vertices are not pushed on the heap at start, instead a front set is maintained. The heap is implemented as a binary heap. The output of the filter is a set of lines describing the shortest path from Start\-Vertex to End\-Vertex.

To create an instance of class vtk\-Dijkstra\-Graph\-Geodesic\-Path, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDijkstraGraphGeodesicPath
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Dijkstra\-Graph\-Geodesic\-Path has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Dijkstra\-Graph\-Geodesic\-Path class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methids for printing and determining type information.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methids for printing and determining type information.  
\item {\ttfamily vtk\-Dijkstra\-Graph\-Geodesic\-Path = obj.\-New\-Instance ()} -\/ Standard methids for printing and determining type information.  
\item {\ttfamily vtk\-Dijkstra\-Graph\-Geodesic\-Path = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methids for printing and determining type information.  
\item {\ttfamily vtk\-Id\-List = obj.\-Get\-Id\-List ()} -\/ The vertex ids (of the input polydata) on the shortest path  
\item {\ttfamily obj.\-Set\-Stop\-When\-End\-Reached (int )} -\/ Stop when the end vertex is reached or calculate shortest path to all vertices  
\item {\ttfamily int = obj.\-Get\-Stop\-When\-End\-Reached ()} -\/ Stop when the end vertex is reached or calculate shortest path to all vertices  
\item {\ttfamily obj.\-Stop\-When\-End\-Reached\-On ()} -\/ Stop when the end vertex is reached or calculate shortest path to all vertices  
\item {\ttfamily obj.\-Stop\-When\-End\-Reached\-Off ()} -\/ Stop when the end vertex is reached or calculate shortest path to all vertices  
\item {\ttfamily obj.\-Set\-Use\-Scalar\-Weights (int )} -\/ Use scalar values in the edge weight (experimental)  
\item {\ttfamily int = obj.\-Get\-Use\-Scalar\-Weights ()} -\/ Use scalar values in the edge weight (experimental)  
\item {\ttfamily obj.\-Use\-Scalar\-Weights\-On ()} -\/ Use scalar values in the edge weight (experimental)  
\item {\ttfamily obj.\-Use\-Scalar\-Weights\-Off ()} -\/ Use scalar values in the edge weight (experimental)  
\item {\ttfamily obj.\-Set\-Repel\-Path\-From\-Vertices (int )} -\/ Use the input point to repel the path by assigning high costs.  
\item {\ttfamily int = obj.\-Get\-Repel\-Path\-From\-Vertices ()} -\/ Use the input point to repel the path by assigning high costs.  
\item {\ttfamily obj.\-Repel\-Path\-From\-Vertices\-On ()} -\/ Use the input point to repel the path by assigning high costs.  
\item {\ttfamily obj.\-Repel\-Path\-From\-Vertices\-Off ()} -\/ Use the input point to repel the path by assigning high costs.  
\item {\ttfamily obj.\-Set\-Repel\-Vertices (vtk\-Points )} -\/ Specify vtk\-Points to use to repel the path from.  
\item {\ttfamily vtk\-Points = obj.\-Get\-Repel\-Vertices ()} -\/ Specify vtk\-Points to use to repel the path from.  
\item {\ttfamily double = obj.\-Get\-Geodesic\-Length ()}  
\item {\ttfamily obj.\-Get\-Cumulative\-Weights (vtk\-Double\-Array weights)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkdijkstraimagegeodesicpath}{}\section{vtk\-Dijkstra\-Image\-Geodesic\-Path}\label{vtkgraphics_vtkdijkstraimagegeodesicpath}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Takes as input a polyline and an image representing a 2\-D cost function and performs a single source shortest path calculation. Dijkstra's algorithm is used. The implementation is similar to the one described in Introduction to Algorithms (Second Edition) by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Cliff Stein, published by M\-I\-T Press and Mc\-Graw-\/\-Hill. Some minor enhancement are added though. All vertices are not pushed on the heap at start, instead a front set is maintained. The heap is implemented as a binary heap. The output of the filter is a set of lines describing the shortest path from Start\-Vertex to End\-Vertex. See parent class vtk\-Dijkstra\-Graph\-Geodesic\-Path for the implementation.

To create an instance of class vtk\-Dijkstra\-Image\-Geodesic\-Path, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDijkstraImageGeodesicPath
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Dijkstra\-Image\-Geodesic\-Path has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Dijkstra\-Image\-Geodesic\-Path class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methids for printing and determining type information.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methids for printing and determining type information.  
\item {\ttfamily vtk\-Dijkstra\-Image\-Geodesic\-Path = obj.\-New\-Instance ()} -\/ Standard methids for printing and determining type information.  
\item {\ttfamily vtk\-Dijkstra\-Image\-Geodesic\-Path = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methids for printing and determining type information.  
\item {\ttfamily obj.\-Set\-Input (vtk\-Data\-Object )} -\/ Specify the image object which is used as a cost function.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Input\-As\-Image\-Data ()} -\/ Specify the image object which is used as a cost function.  
\item {\ttfamily obj.\-Set\-Image\-Weight (double )} -\/ Image cost weight.  
\item {\ttfamily double = obj.\-Get\-Image\-Weight ()} -\/ Image cost weight.  
\item {\ttfamily obj.\-Set\-Edge\-Length\-Weight (double )} -\/ Edge length cost weight.  
\item {\ttfamily double = obj.\-Get\-Edge\-Length\-Weight ()} -\/ Edge length cost weight.  
\item {\ttfamily obj.\-Set\-Curvature\-Weight (double )} -\/ Curvature cost weight.  
\item {\ttfamily double = obj.\-Get\-Curvature\-Weight\-Min\-Value ()} -\/ Curvature cost weight.  
\item {\ttfamily double = obj.\-Get\-Curvature\-Weight\-Max\-Value ()} -\/ Curvature cost weight.  
\item {\ttfamily double = obj.\-Get\-Curvature\-Weight ()} -\/ Curvature cost weight.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkdiscretemarchingcubes}{}\section{vtk\-Discrete\-Marching\-Cubes}\label{vtkgraphics_vtkdiscretemarchingcubes}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
takes as input a volume (e.\-g., 3\-D structured point set) of segmentation labels and generates on output one or more models representing the boundaries between the specified label and the adjacent structures. One or more label values must be specified to generate the models. The boundary positions are always defined to be half-\/way between adjacent voxels. This filter works best with integral scalar values. If Compute\-Scalars is on (the default), each output cell will have cell data that corresponds to the scalar value (segmentation label) of the corresponding cube. Note that this differs from vtk\-Marching\-Cubes, which stores the scalar value as point data. The rationale for this difference is that cell vertices may be shared between multiple cells. This also means that the resultant polydata may be non-\/manifold (cell faces may be coincident). To further process the polydata, users should either\-: 1) extract cells that have a common scalar value using vtk\-Threshold, or 2) process the data with filters that can handle non-\/manifold polydata (e.\-g. vtk\-Windowed\-Sinc\-Poly\-Data\-Filter). Also note, Normals and Gradients are not computed.

To create an instance of class vtk\-Discrete\-Marching\-Cubes, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDiscreteMarchingCubes
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Discrete\-Marching\-Cubes has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Discrete\-Marching\-Cubes class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Discrete\-Marching\-Cubes = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Discrete\-Marching\-Cubes = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkdisksource}{}\section{vtk\-Disk\-Source}\label{vtkgraphics_vtkdisksource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Disk\-Source creates a polygonal disk with a hole in the center. The disk has zero height. The user can specify the inner and outer radius of the disk, and the radial and circumferential resolution of the polygonal representation.

To create an instance of class vtk\-Disk\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDiskSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Disk\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Disk\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Disk\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Disk\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Inner\-Radius (double )} -\/ Specify inner radius of hole in disc.  
\item {\ttfamily double = obj.\-Get\-Inner\-Radius\-Min\-Value ()} -\/ Specify inner radius of hole in disc.  
\item {\ttfamily double = obj.\-Get\-Inner\-Radius\-Max\-Value ()} -\/ Specify inner radius of hole in disc.  
\item {\ttfamily double = obj.\-Get\-Inner\-Radius ()} -\/ Specify inner radius of hole in disc.  
\item {\ttfamily obj.\-Set\-Outer\-Radius (double )} -\/ Specify outer radius of disc.  
\item {\ttfamily double = obj.\-Get\-Outer\-Radius\-Min\-Value ()} -\/ Specify outer radius of disc.  
\item {\ttfamily double = obj.\-Get\-Outer\-Radius\-Max\-Value ()} -\/ Specify outer radius of disc.  
\item {\ttfamily double = obj.\-Get\-Outer\-Radius ()} -\/ Specify outer radius of disc.  
\item {\ttfamily obj.\-Set\-Radial\-Resolution (int )} -\/ Set the number of points in radius direction.  
\item {\ttfamily int = obj.\-Get\-Radial\-Resolution\-Min\-Value ()} -\/ Set the number of points in radius direction.  
\item {\ttfamily int = obj.\-Get\-Radial\-Resolution\-Max\-Value ()} -\/ Set the number of points in radius direction.  
\item {\ttfamily int = obj.\-Get\-Radial\-Resolution ()} -\/ Set the number of points in radius direction.  
\item {\ttfamily obj.\-Set\-Circumferential\-Resolution (int )} -\/ Set the number of points in circumferential direction.  
\item {\ttfamily int = obj.\-Get\-Circumferential\-Resolution\-Min\-Value ()} -\/ Set the number of points in circumferential direction.  
\item {\ttfamily int = obj.\-Get\-Circumferential\-Resolution\-Max\-Value ()} -\/ Set the number of points in circumferential direction.  
\item {\ttfamily int = obj.\-Get\-Circumferential\-Resolution ()} -\/ Set the number of points in circumferential direction.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkedgepoints}{}\section{vtk\-Edge\-Points}\label{vtkgraphics_vtkedgepoints}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Edge\-Points is a filter that takes as input any dataset and generates for output a set of points that lie on an isosurface. The points are created by interpolation along cells edges whose end-\/points are below and above the contour value.

To create an instance of class vtk\-Edge\-Points, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkEdgePoints
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Edge\-Points has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Edge\-Points class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Edge\-Points = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Edge\-Points = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Value (double )} -\/ Set/get the contour value.  
\item {\ttfamily double = obj.\-Get\-Value ()} -\/ Set/get the contour value.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkedgesubdivisioncriterion}{}\section{vtk\-Edge\-Subdivision\-Criterion}\label{vtkgraphics_vtkedgesubdivisioncriterion}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Descendants of this abstract class are used to decide whether a piecewise linear approximation (triangles, lines, ... ) to some nonlinear geometry should be subdivided. This decision may be based on an absolute error metric (chord error) or on some view-\/dependent metric (chord error compared to device resolution) or on some abstract metric (color error). Or anything else, really. Just so long as you implement the Evaluate\-Edge member, all will be well.

To create an instance of class vtk\-Edge\-Subdivision\-Criterion, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkEdgeSubdivisionCriterion
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Edge\-Subdivision\-Criterion has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Edge\-Subdivision\-Criterion class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Edge\-Subdivision\-Criterion = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Edge\-Subdivision\-Criterion = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily bool = obj.\-Evaluate\-Edge (double p0, double p1, double p2, int field\-\_\-start)} -\/ You must implement this member function in a subclass. It will be called by {\ttfamily vtk\-Streaming\-Tessellator} for each edge in each primitive that vtk\-Streaming\-Tessellator generates.  
\item {\ttfamily int = obj.\-Pass\-Field (int source\-Id, int source\-Size, vtk\-Streaming\-Tessellator t)} -\/ This is a helper routine called by {\ttfamily Pass\-Fields()} which you may also call directly; it adds {\itshape source\-Size} to the size of the output vertex field values. The offset of the {\itshape source\-Id} field in the output vertex array is returned. -\/1 is returned if {\itshape source\-Size} would force the output to have more than {\itshape vtk\-Streaming\-Tessellator\-::\-Max\-Field\-Size} field values per vertex.  
\item {\ttfamily obj.\-Reset\-Field\-List ()} -\/ Don't pass any field values in the vertex pointer. This is used to reset the list of fields to pass after a successful run of vtk\-Streaming\-Tessellator.  
\item {\ttfamily bool = obj.\-Dont\-Pass\-Field (int source\-Id, vtk\-Streaming\-Tessellator t)} -\/ This does the opposite of {\ttfamily Pass\-Field()}; it removes a field from the output (assuming the field was set to be passed). Returns true if any action was taken, false otherwise.  
\item {\ttfamily int = obj.\-Get\-Output\-Field (int field\-Id) const} -\/ Return the output I\-D of an input field. Returns -\/1 if {\itshape field\-Id} is not set to be passed to the output.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Fields () const} -\/ Return the number of fields being evaluated at each output vertex. This is the length of the arrays returned by {\ttfamily Get\-Field\-Ids()} and {\ttfamily Get\-Field\-Offsets()}.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkelevationfilter}{}\section{vtk\-Elevation\-Filter}\label{vtkgraphics_vtkelevationfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Elevation\-Filter is a filter to generate scalar values from a dataset. The scalar values lie within a user specified range, and are generated by computing a projection of each dataset point onto a line. The line can be oriented arbitrarily. A typical example is to generate scalars based on elevation or height above a plane.

To create an instance of class vtk\-Elevation\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkElevationFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Elevation\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Elevation\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Elevation\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Elevation\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Low\-Point (double , double , double )} -\/ Define one end of the line (small scalar values). Default is (0,0,0).  
\item {\ttfamily obj.\-Set\-Low\-Point (double a\mbox{[}3\mbox{]})} -\/ Define one end of the line (small scalar values). Default is (0,0,0).  
\item {\ttfamily double = obj. Get\-Low\-Point ()} -\/ Define one end of the line (small scalar values). Default is (0,0,0).  
\item {\ttfamily obj.\-Set\-High\-Point (double , double , double )} -\/ Define other end of the line (large scalar values). Default is (0,0,1).  
\item {\ttfamily obj.\-Set\-High\-Point (double a\mbox{[}3\mbox{]})} -\/ Define other end of the line (large scalar values). Default is (0,0,1).  
\item {\ttfamily double = obj. Get\-High\-Point ()} -\/ Define other end of the line (large scalar values). Default is (0,0,1).  
\item {\ttfamily obj.\-Set\-Scalar\-Range (double , double )} -\/ Specify range to map scalars into. Default is \mbox{[}0, 1\mbox{]}.  
\item {\ttfamily obj.\-Set\-Scalar\-Range (double a\mbox{[}2\mbox{]})} -\/ Specify range to map scalars into. Default is \mbox{[}0, 1\mbox{]}.  
\item {\ttfamily double = obj. Get\-Scalar\-Range ()} -\/ Specify range to map scalars into. Default is \mbox{[}0, 1\mbox{]}.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkellipticalbuttonsource}{}\section{vtk\-Elliptical\-Button\-Source}\label{vtkgraphics_vtkellipticalbuttonsource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Elliptical\-Button\-Source creates a ellipsoidal shaped button with texture coordinates suitable for application of a texture map. This provides a way to make nice looking 3\-D buttons. The buttons are represented as vtk\-Poly\-Data that includes texture coordinates and normals. The button lies in the x-\/y plane.

To use this class you must define the major and minor axes lengths of an ellipsoid (expressed as width (x), height (y) and depth (z)). The button has a rectangular mesh region in the center with texture coordinates that range smoothly from (0,1). (This flat region is called the texture region.) The outer, curved portion of the button (called the shoulder) has texture coordinates set to a user specified value (by default (0,0). (This results in coloring the button curve the same color as the (s,t) location of the texture map.) The resolution in the radial direction, the texture region, and the shoulder region must also be set. The button can be moved by specifying an origin.

To create an instance of class vtk\-Elliptical\-Button\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkEllipticalButtonSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Elliptical\-Button\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Elliptical\-Button\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Elliptical\-Button\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Elliptical\-Button\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Width (double )} -\/ Set/\-Get the width of the button (the x-\/ellipsoid axis length $\ast$ 2).  
\item {\ttfamily double = obj.\-Get\-Width\-Min\-Value ()} -\/ Set/\-Get the width of the button (the x-\/ellipsoid axis length $\ast$ 2).  
\item {\ttfamily double = obj.\-Get\-Width\-Max\-Value ()} -\/ Set/\-Get the width of the button (the x-\/ellipsoid axis length $\ast$ 2).  
\item {\ttfamily double = obj.\-Get\-Width ()} -\/ Set/\-Get the width of the button (the x-\/ellipsoid axis length $\ast$ 2).  
\item {\ttfamily obj.\-Set\-Height (double )} -\/ Set/\-Get the height of the button (the y-\/ellipsoid axis length $\ast$ 2).  
\item {\ttfamily double = obj.\-Get\-Height\-Min\-Value ()} -\/ Set/\-Get the height of the button (the y-\/ellipsoid axis length $\ast$ 2).  
\item {\ttfamily double = obj.\-Get\-Height\-Max\-Value ()} -\/ Set/\-Get the height of the button (the y-\/ellipsoid axis length $\ast$ 2).  
\item {\ttfamily double = obj.\-Get\-Height ()} -\/ Set/\-Get the height of the button (the y-\/ellipsoid axis length $\ast$ 2).  
\item {\ttfamily obj.\-Set\-Depth (double )} -\/ Set/\-Get the depth of the button (the z-\/eliipsoid axis length).  
\item {\ttfamily double = obj.\-Get\-Depth\-Min\-Value ()} -\/ Set/\-Get the depth of the button (the z-\/eliipsoid axis length).  
\item {\ttfamily double = obj.\-Get\-Depth\-Max\-Value ()} -\/ Set/\-Get the depth of the button (the z-\/eliipsoid axis length).  
\item {\ttfamily double = obj.\-Get\-Depth ()} -\/ Set/\-Get the depth of the button (the z-\/eliipsoid axis length).  
\item {\ttfamily obj.\-Set\-Circumferential\-Resolution (int )} -\/ Specify the resolution of the button in the circumferential direction.  
\item {\ttfamily int = obj.\-Get\-Circumferential\-Resolution\-Min\-Value ()} -\/ Specify the resolution of the button in the circumferential direction.  
\item {\ttfamily int = obj.\-Get\-Circumferential\-Resolution\-Max\-Value ()} -\/ Specify the resolution of the button in the circumferential direction.  
\item {\ttfamily int = obj.\-Get\-Circumferential\-Resolution ()} -\/ Specify the resolution of the button in the circumferential direction.  
\item {\ttfamily obj.\-Set\-Texture\-Resolution (int )} -\/ Specify the resolution of the texture in the radial direction in the texture region.  
\item {\ttfamily int = obj.\-Get\-Texture\-Resolution\-Min\-Value ()} -\/ Specify the resolution of the texture in the radial direction in the texture region.  
\item {\ttfamily int = obj.\-Get\-Texture\-Resolution\-Max\-Value ()} -\/ Specify the resolution of the texture in the radial direction in the texture region.  
\item {\ttfamily int = obj.\-Get\-Texture\-Resolution ()} -\/ Specify the resolution of the texture in the radial direction in the texture region.  
\item {\ttfamily obj.\-Set\-Shoulder\-Resolution (int )} -\/ Specify the resolution of the texture in the radial direction in the shoulder region.  
\item {\ttfamily int = obj.\-Get\-Shoulder\-Resolution\-Min\-Value ()} -\/ Specify the resolution of the texture in the radial direction in the shoulder region.  
\item {\ttfamily int = obj.\-Get\-Shoulder\-Resolution\-Max\-Value ()} -\/ Specify the resolution of the texture in the radial direction in the shoulder region.  
\item {\ttfamily int = obj.\-Get\-Shoulder\-Resolution ()} -\/ Specify the resolution of the texture in the radial direction in the shoulder region.  
\item {\ttfamily obj.\-Set\-Radial\-Ratio (double )} -\/ Set/\-Get the radial ratio. This is the measure of the radius of the outer ellipsoid to the inner ellipsoid of the button. The outer ellipsoid is the boundary of the button defined by the height and width. The inner ellipsoid circumscribes the texture region. Larger Radial\-Ratio's cause the button to be more rounded (and the texture region to be smaller); smaller ratios produce sharply curved shoulders with a larger texture region.  
\item {\ttfamily double = obj.\-Get\-Radial\-Ratio\-Min\-Value ()} -\/ Set/\-Get the radial ratio. This is the measure of the radius of the outer ellipsoid to the inner ellipsoid of the button. The outer ellipsoid is the boundary of the button defined by the height and width. The inner ellipsoid circumscribes the texture region. Larger Radial\-Ratio's cause the button to be more rounded (and the texture region to be smaller); smaller ratios produce sharply curved shoulders with a larger texture region.  
\item {\ttfamily double = obj.\-Get\-Radial\-Ratio\-Max\-Value ()} -\/ Set/\-Get the radial ratio. This is the measure of the radius of the outer ellipsoid to the inner ellipsoid of the button. The outer ellipsoid is the boundary of the button defined by the height and width. The inner ellipsoid circumscribes the texture region. Larger Radial\-Ratio's cause the button to be more rounded (and the texture region to be smaller); smaller ratios produce sharply curved shoulders with a larger texture region.  
\item {\ttfamily double = obj.\-Get\-Radial\-Ratio ()} -\/ Set/\-Get the radial ratio. This is the measure of the radius of the outer ellipsoid to the inner ellipsoid of the button. The outer ellipsoid is the boundary of the button defined by the height and width. The inner ellipsoid circumscribes the texture region. Larger Radial\-Ratio's cause the button to be more rounded (and the texture region to be smaller); smaller ratios produce sharply curved shoulders with a larger texture region.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextractarraysovertime}{}\section{vtk\-Extract\-Arrays\-Over\-Time}\label{vtkgraphics_vtkextractarraysovertime}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Extract\-Arrays\-Over\-Time extracts a selection over time. The output is a multiblock dataset. If selection content type is vtk\-Selection\-::\-Locations, then each output block corresponds to each probed location. Otherwise, each output block corresponds to an extracted cell/point depending on whether the selection field type is C\-E\-L\-L or P\-O\-I\-N\-T. Each block is a vtk\-Table with a column named Time (or Time\-Data if Time exists in the input). When extracting point data, the input point coordinates are copied to a column named Point Coordinates or Points (if Point Coordinates exists in the input). This algorithm does not produce a T\-I\-M\-E\-\_\-\-S\-T\-E\-P\-S or T\-I\-M\-E\-\_\-\-R\-A\-N\-G\-E information because it works across time. .Section Caveat This algorithm works only with source that produce T\-I\-M\-E\-\_\-\-S\-T\-E\-P\-S(). Continuous time range is not yet supported.

To create an instance of class vtk\-Extract\-Arrays\-Over\-Time, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractArraysOverTime
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Arrays\-Over\-Time has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extract\-Arrays\-Over\-Time class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Arrays\-Over\-Time = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Arrays\-Over\-Time = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Time\-Steps ()} -\/ Get the number of time steps  
\item {\ttfamily obj.\-Set\-Selection\-Connection (vtk\-Algorithm\-Output alg\-Output)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextractblock}{}\section{vtk\-Extract\-Block}\label{vtkgraphics_vtkextractblock}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Extract\-Block is a filter that extracts blocks from a multiblock dataset. Each node in the multi-\/block tree is identified by an {\ttfamily index}. The index can be obtained by performing a preorder traversal of the tree (including empty nodes). eg. A(B (D, E), C(\-F, G)). Inorder traversal yields\-: A, B, D, E, C, F, G Index of A is 0, while index of C is 4.

To create an instance of class vtk\-Extract\-Block, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractBlock
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Block has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extract\-Block class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Block = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Block = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Index (int index)} -\/ Select the block indices to extract. Each node in the multi-\/block tree is identified by an {\ttfamily index}. The index can be obtained by performing a preorder traversal of the tree (including empty nodes). eg. A(B (D, E), C(\-F, G)). Inorder traversal yields\-: A, B, D, E, C, F, G Index of A is 0, while index of C is 4.  
\item {\ttfamily obj.\-Remove\-Index (int index)} -\/ Select the block indices to extract. Each node in the multi-\/block tree is identified by an {\ttfamily index}. The index can be obtained by performing a preorder traversal of the tree (including empty nodes). eg. A(B (D, E), C(\-F, G)). Inorder traversal yields\-: A, B, D, E, C, F, G Index of A is 0, while index of C is 4.  
\item {\ttfamily obj.\-Remove\-All\-Indices ()} -\/ Select the block indices to extract. Each node in the multi-\/block tree is identified by an {\ttfamily index}. The index can be obtained by performing a preorder traversal of the tree (including empty nodes). eg. A(B (D, E), C(\-F, G)). Inorder traversal yields\-: A, B, D, E, C, F, G Index of A is 0, while index of C is 4.  
\item {\ttfamily obj.\-Set\-Prune\-Output (int )} -\/ When set, the output mutliblock dataset will be pruned to remove empty nodes. On by default.  
\item {\ttfamily int = obj.\-Get\-Prune\-Output ()} -\/ When set, the output mutliblock dataset will be pruned to remove empty nodes. On by default.  
\item {\ttfamily obj.\-Prune\-Output\-On ()} -\/ When set, the output mutliblock dataset will be pruned to remove empty nodes. On by default.  
\item {\ttfamily obj.\-Prune\-Output\-Off ()} -\/ When set, the output mutliblock dataset will be pruned to remove empty nodes. On by default.  
\item {\ttfamily obj.\-Set\-Maintain\-Structure (int )} -\/ This is used only when Prune\-Output is O\-N. By default, when pruning the output i.\-e. remove empty blocks, if node has only 1 non-\/null child block, then that node is removed. To preserve these parent nodes, set this flag to true. Off by default.  
\item {\ttfamily int = obj.\-Get\-Maintain\-Structure ()} -\/ This is used only when Prune\-Output is O\-N. By default, when pruning the output i.\-e. remove empty blocks, if node has only 1 non-\/null child block, then that node is removed. To preserve these parent nodes, set this flag to true. Off by default.  
\item {\ttfamily obj.\-Maintain\-Structure\-On ()} -\/ This is used only when Prune\-Output is O\-N. By default, when pruning the output i.\-e. remove empty blocks, if node has only 1 non-\/null child block, then that node is removed. To preserve these parent nodes, set this flag to true. Off by default.  
\item {\ttfamily obj.\-Maintain\-Structure\-Off ()} -\/ This is used only when Prune\-Output is O\-N. By default, when pruning the output i.\-e. remove empty blocks, if node has only 1 non-\/null child block, then that node is removed. To preserve these parent nodes, set this flag to true. Off by default.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextractcells}{}\section{vtk\-Extract\-Cells}\label{vtkgraphics_vtkextractcells}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Given a vtk\-Data\-Set and a list of cell Ids, create a vtk\-Unstructured\-Grid composed of these cells. If the cell list is empty when vtk\-Extract\-Cells executes, it will set up the ugrid, point and cell arrays, with no points, cells or data.

To create an instance of class vtk\-Extract\-Cells, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractCells
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Cells has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extract\-Cells class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Cells = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Cells = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Cell\-List (vtk\-Id\-List l)}  
\item {\ttfamily obj.\-Add\-Cell\-List (vtk\-Id\-List l)}  
\item {\ttfamily obj.\-Add\-Cell\-Range (vtk\-Id\-Type from, vtk\-Id\-Type to)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextractdataovertime}{}\section{vtk\-Extract\-Data\-Over\-Time}\label{vtkgraphics_vtkextractdataovertime}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This filter extracts the point data from a time sequence and specified index and creates an output of the same type as the input but with Points containing \char`\"{}number of time steps\char`\"{} points; the point and Point\-Data corresponding to the Point\-Index are extracted at each time step and added to the output. A Point\-Data array is added called \char`\"{}\-Time\char`\"{} (or \char`\"{}\-Time\-Data\char`\"{} if there is already an array called \char`\"{}\-Time\char`\"{}), which is the time at each index.

To create an instance of class vtk\-Extract\-Data\-Over\-Time, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractDataOverTime
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Data\-Over\-Time has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extract\-Data\-Over\-Time class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Data\-Over\-Time = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Data\-Over\-Time = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Point\-Index (int )} -\/ Index of point to extract at each time step  
\item {\ttfamily int = obj.\-Get\-Point\-Index ()} -\/ Index of point to extract at each time step  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Time\-Steps ()} -\/ Get the number of time steps  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextractdatasets}{}\section{vtk\-Extract\-Data\-Sets}\label{vtkgraphics_vtkextractdatasets}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Extract\-Data\-Sets accepts a vtk\-Hierarchical\-Box\-Data\-Set as input and extracts different datasets from different levels. The output is vtk\-Hierarchical\-Box\-Data\-Set with same structure as the input with only the selected datasets passed through.

To create an instance of class vtk\-Extract\-Data\-Sets, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractDataSets
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Data\-Sets has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extract\-Data\-Sets class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Data\-Sets = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Data\-Sets = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Data\-Set (int level, int idx)} -\/ Add a dataset to be extracted.  
\item {\ttfamily obj.\-Clear\-Data\-Set\-List ()} -\/ Remove all entries from the list of datasets to be extracted.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextractedges}{}\section{vtk\-Extract\-Edges}\label{vtkgraphics_vtkextractedges}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Extract\-Edges is a filter to extract edges from a dataset. Edges are extracted as lines or polylines.

To create an instance of class vtk\-Extract\-Edges, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractEdges
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Edges has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extract\-Edges class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Edges = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Edges = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\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 M\-Time also considering the locator.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextractgeometry}{}\section{vtk\-Extract\-Geometry}\label{vtkgraphics_vtkextractgeometry}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Extract\-Geometry extracts from its input dataset all cells that are either completely inside or outside of a specified implicit function. Any type of dataset can be input to this filter. On output the filter generates an unstructured grid.

To use this filter you must specify an implicit function. You must also specify whethter to extract cells lying inside or outside of the implicit function. (The inside of an implicit function is the negative values region.) An option exists to extract cells that are neither inside or outside (i.\-e., boundary).

A more efficient version of this filter is available for vtk\-Poly\-Data input. See vtk\-Extract\-Poly\-Data\-Geometry.

To create an instance of class vtk\-Extract\-Geometry, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractGeometry
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Geometry has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extract\-Geometry class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Geometry = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Geometry = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return the M\-Time taking into account changes to the implicit function  
\item {\ttfamily obj.\-Set\-Implicit\-Function (vtk\-Implicit\-Function )} -\/ Specify the implicit function for inside/outside checks.  
\item {\ttfamily vtk\-Implicit\-Function = obj.\-Get\-Implicit\-Function ()} -\/ Specify the implicit function for inside/outside checks.  
\item {\ttfamily obj.\-Set\-Extract\-Inside (int )} -\/ Boolean controls whether to extract cells that are inside of implicit function (Extract\-Inside == 1) or outside of implicit function (Extract\-Inside == 0).  
\item {\ttfamily int = obj.\-Get\-Extract\-Inside ()} -\/ Boolean controls whether to extract cells that are inside of implicit function (Extract\-Inside == 1) or outside of implicit function (Extract\-Inside == 0).  
\item {\ttfamily obj.\-Extract\-Inside\-On ()} -\/ Boolean controls whether to extract cells that are inside of implicit function (Extract\-Inside == 1) or outside of implicit function (Extract\-Inside == 0).  
\item {\ttfamily obj.\-Extract\-Inside\-Off ()} -\/ Boolean controls whether to extract cells that are inside of implicit function (Extract\-Inside == 1) or outside of implicit function (Extract\-Inside == 0).  
\item {\ttfamily obj.\-Set\-Extract\-Boundary\-Cells (int )} -\/ Boolean controls whether to extract cells that are partially inside. By default, Extract\-Boundary\-Cells is off.  
\item {\ttfamily int = obj.\-Get\-Extract\-Boundary\-Cells ()} -\/ Boolean controls whether to extract cells that are partially inside. By default, Extract\-Boundary\-Cells is off.  
\item {\ttfamily obj.\-Extract\-Boundary\-Cells\-On ()} -\/ Boolean controls whether to extract cells that are partially inside. By default, Extract\-Boundary\-Cells is off.  
\item {\ttfamily obj.\-Extract\-Boundary\-Cells\-Off ()} -\/ Boolean controls whether to extract cells that are partially inside. By default, Extract\-Boundary\-Cells is off.  
\item {\ttfamily obj.\-Set\-Extract\-Only\-Boundary\-Cells (int )} -\/ Boolean controls whether to extract cells that are partially inside. By default, Extract\-Boundary\-Cells is off.  
\item {\ttfamily int = obj.\-Get\-Extract\-Only\-Boundary\-Cells ()} -\/ Boolean controls whether to extract cells that are partially inside. By default, Extract\-Boundary\-Cells is off.  
\item {\ttfamily obj.\-Extract\-Only\-Boundary\-Cells\-On ()} -\/ Boolean controls whether to extract cells that are partially inside. By default, Extract\-Boundary\-Cells is off.  
\item {\ttfamily obj.\-Extract\-Only\-Boundary\-Cells\-Off ()} -\/ Boolean controls whether to extract cells that are partially inside. By default, Extract\-Boundary\-Cells is off.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextractgrid}{}\section{vtk\-Extract\-Grid}\label{vtkgraphics_vtkextractgrid}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Extract\-Grid is a filter that selects a portion of an input structured grid dataset, or subsamples an input dataset. (The selected portion of interested is referred to as the Volume Of Interest, or V\-O\-I.) The output of this filter is a structured grid dataset. The filter treats input data of any topological dimension (i.\-e., point, line, image, or volume) and can generate output data of any topological dimension.

To use this filter set the V\-O\-I ivar which are i-\/j-\/k min/max indices that specify a rectangular region in the data. (Note that these are 0-\/offset.) You can also specify a sampling rate to subsample the data.

Typical applications of this filter are to extract a plane from a grid for contouring, subsampling large grids to reduce data size, or extracting regions of a grid with interesting data.

To create an instance of class vtk\-Extract\-Grid, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractGrid
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Grid has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extract\-Grid class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Grid = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Grid = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-V\-O\-I (int , int , int , int , int , int )} -\/ Specify i-\/j-\/k (min,max) pairs to extract. The resulting structured grid dataset can be of any topological dimension (i.\-e., point, line, plane, or 3\-D grid).  
\item {\ttfamily obj.\-Set\-V\-O\-I (int a\mbox{[}6\mbox{]})} -\/ Specify i-\/j-\/k (min,max) pairs to extract. The resulting structured grid dataset can be of any topological dimension (i.\-e., point, line, plane, or 3\-D grid).  
\item {\ttfamily int = obj. Get\-V\-O\-I ()} -\/ Specify i-\/j-\/k (min,max) pairs to extract. The resulting structured grid dataset can be of any topological dimension (i.\-e., point, line, plane, or 3\-D grid).  
\item {\ttfamily obj.\-Set\-Sample\-Rate (int , int , int )} -\/ Set the sampling rate in the i, j, and k directions. If the rate is $>$ 1, then the resulting V\-O\-I will be subsampled representation of the input. For example, if the Sample\-Rate=(2,2,2), every other point will be selected, resulting in a volume 1/8th the original size.  
\item {\ttfamily obj.\-Set\-Sample\-Rate (int a\mbox{[}3\mbox{]})} -\/ Set the sampling rate in the i, j, and k directions. If the rate is $>$ 1, then the resulting V\-O\-I will be subsampled representation of the input. For example, if the Sample\-Rate=(2,2,2), every other point will be selected, resulting in a volume 1/8th the original size.  
\item {\ttfamily int = obj. Get\-Sample\-Rate ()} -\/ Set the sampling rate in the i, j, and k directions. If the rate is $>$ 1, then the resulting V\-O\-I will be subsampled representation of the input. For example, if the Sample\-Rate=(2,2,2), every other point will be selected, resulting in a volume 1/8th the original size.  
\item {\ttfamily obj.\-Set\-Include\-Boundary (int )} -\/ Control whether to enforce that the \char`\"{}boundary\char`\"{} of the grid is output in the subsampling process. (This ivar only has effect when the Sample\-Rate in any direction is not equal to 1.) When this ivar Include\-Boundary is on, the subsampling will always include the boundary of the grid even though the sample rate is not an even multiple of the grid dimensions. (By default Include\-Boundary is off.)  
\item {\ttfamily int = obj.\-Get\-Include\-Boundary ()} -\/ Control whether to enforce that the \char`\"{}boundary\char`\"{} of the grid is output in the subsampling process. (This ivar only has effect when the Sample\-Rate in any direction is not equal to 1.) When this ivar Include\-Boundary is on, the subsampling will always include the boundary of the grid even though the sample rate is not an even multiple of the grid dimensions. (By default Include\-Boundary is off.)  
\item {\ttfamily obj.\-Include\-Boundary\-On ()} -\/ Control whether to enforce that the \char`\"{}boundary\char`\"{} of the grid is output in the subsampling process. (This ivar only has effect when the Sample\-Rate in any direction is not equal to 1.) When this ivar Include\-Boundary is on, the subsampling will always include the boundary of the grid even though the sample rate is not an even multiple of the grid dimensions. (By default Include\-Boundary is off.)  
\item {\ttfamily obj.\-Include\-Boundary\-Off ()} -\/ Control whether to enforce that the \char`\"{}boundary\char`\"{} of the grid is output in the subsampling process. (This ivar only has effect when the Sample\-Rate in any direction is not equal to 1.) When this ivar Include\-Boundary is on, the subsampling will always include the boundary of the grid even though the sample rate is not an even multiple of the grid dimensions. (By default Include\-Boundary is off.)  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextractlevel}{}\section{vtk\-Extract\-Level}\label{vtkgraphics_vtkextractlevel}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Extract\-Level filter extracts the levels between (and including) the user specified min and max levels.

To create an instance of class vtk\-Extract\-Level, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractLevel
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Level has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extract\-Level class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Level = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Level = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Level (int level)} -\/ Select the levels that should be extracted. All other levels will have no datasets in them.  
\item {\ttfamily obj.\-Remove\-Level (int level)} -\/ Select the levels that should be extracted. All other levels will have no datasets in them.  
\item {\ttfamily obj.\-Remove\-All\-Levels ()} -\/ Select the levels that should be extracted. All other levels will have no datasets in them.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextractpolydatageometry}{}\section{vtk\-Extract\-Poly\-Data\-Geometry}\label{vtkgraphics_vtkextractpolydatageometry}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Extract\-Poly\-Data\-Geometry extracts from its input vtk\-Poly\-Data all cells that are either completely inside or outside of a specified implicit function. This filter is specialized to vtk\-Poly\-Data. On output the filter generates vtk\-Poly\-Data.

To use this filter you must specify an implicit function. You must also specify whether to extract cells lying inside or outside of the implicit function. (The inside of an implicit function is the negative values region.) An option exists to extract cells that are neither inside nor outside (i.\-e., boundary).

A more general version of this filter is available for arbitrary vtk\-Data\-Set input (see vtk\-Extract\-Geometry).

To create an instance of class vtk\-Extract\-Poly\-Data\-Geometry, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractPolyDataGeometry
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Poly\-Data\-Geometry has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extract\-Poly\-Data\-Geometry class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Poly\-Data\-Geometry = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Poly\-Data\-Geometry = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return the M\-Time taking into account changes to the implicit function  
\item {\ttfamily obj.\-Set\-Implicit\-Function (vtk\-Implicit\-Function )} -\/ Specify the implicit function for inside/outside checks.  
\item {\ttfamily vtk\-Implicit\-Function = obj.\-Get\-Implicit\-Function ()} -\/ Specify the implicit function for inside/outside checks.  
\item {\ttfamily obj.\-Set\-Extract\-Inside (int )} -\/ Boolean controls whether to extract cells that are inside of implicit function (Extract\-Inside == 1) or outside of implicit function (Extract\-Inside == 0).  
\item {\ttfamily int = obj.\-Get\-Extract\-Inside ()} -\/ Boolean controls whether to extract cells that are inside of implicit function (Extract\-Inside == 1) or outside of implicit function (Extract\-Inside == 0).  
\item {\ttfamily obj.\-Extract\-Inside\-On ()} -\/ Boolean controls whether to extract cells that are inside of implicit function (Extract\-Inside == 1) or outside of implicit function (Extract\-Inside == 0).  
\item {\ttfamily obj.\-Extract\-Inside\-Off ()} -\/ Boolean controls whether to extract cells that are inside of implicit function (Extract\-Inside == 1) or outside of implicit function (Extract\-Inside == 0).  
\item {\ttfamily obj.\-Set\-Extract\-Boundary\-Cells (int )} -\/ Boolean controls whether to extract cells that are partially inside. By default, Extract\-Boundary\-Cells is off.  
\item {\ttfamily int = obj.\-Get\-Extract\-Boundary\-Cells ()} -\/ Boolean controls whether to extract cells that are partially inside. By default, Extract\-Boundary\-Cells is off.  
\item {\ttfamily obj.\-Extract\-Boundary\-Cells\-On ()} -\/ Boolean controls whether to extract cells that are partially inside. By default, Extract\-Boundary\-Cells is off.  
\item {\ttfamily obj.\-Extract\-Boundary\-Cells\-Off ()} -\/ Boolean controls whether to extract cells that are partially inside. By default, Extract\-Boundary\-Cells is off.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextractrectilineargrid}{}\section{vtk\-Extract\-Rectilinear\-Grid}\label{vtkgraphics_vtkextractrectilineargrid}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Extract\-Rectilinear\-Grid rounds out the set of filters that extract a subgrid out of a larger structured data set. R\-Ight now, this filter only supports extracting a V\-O\-I. In the future, it might support strides like the vtk\-Extract grid filter.

To create an instance of class vtk\-Extract\-Rectilinear\-Grid, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractRectilinearGrid
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Rectilinear\-Grid has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extract\-Rectilinear\-Grid class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Rectilinear\-Grid = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Rectilinear\-Grid = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-V\-O\-I (int , int , int , int , int , int )} -\/ Specify i-\/j-\/k (min,max) pairs to extract. The resulting structured grid dataset can be of any topological dimension (i.\-e., point, line, plane, or 3\-D grid).  
\item {\ttfamily obj.\-Set\-V\-O\-I (int a\mbox{[}6\mbox{]})} -\/ Specify i-\/j-\/k (min,max) pairs to extract. The resulting structured grid dataset can be of any topological dimension (i.\-e., point, line, plane, or 3\-D grid).  
\item {\ttfamily int = obj. Get\-V\-O\-I ()} -\/ Specify i-\/j-\/k (min,max) pairs to extract. The resulting structured grid dataset can be of any topological dimension (i.\-e., point, line, plane, or 3\-D grid).  
\item {\ttfamily obj.\-Set\-Sample\-Rate (int , int , int )} -\/ Set the sampling rate in the i, j, and k directions. If the rate is $>$ 1, then the resulting V\-O\-I will be subsampled representation of the input. For example, if the Sample\-Rate=(2,2,2), every other point will be selected, resulting in a volume 1/8th the original size.  
\item {\ttfamily obj.\-Set\-Sample\-Rate (int a\mbox{[}3\mbox{]})} -\/ Set the sampling rate in the i, j, and k directions. If the rate is $>$ 1, then the resulting V\-O\-I will be subsampled representation of the input. For example, if the Sample\-Rate=(2,2,2), every other point will be selected, resulting in a volume 1/8th the original size.  
\item {\ttfamily int = obj. Get\-Sample\-Rate ()} -\/ Set the sampling rate in the i, j, and k directions. If the rate is $>$ 1, then the resulting V\-O\-I will be subsampled representation of the input. For example, if the Sample\-Rate=(2,2,2), every other point will be selected, resulting in a volume 1/8th the original size.  
\item {\ttfamily obj.\-Set\-Include\-Boundary (int )} -\/ Control whether to enforce that the \char`\"{}boundary\char`\"{} of the grid is output in the subsampling process. (This ivar only has effect when the Sample\-Rate in any direction is not equal to 1.) When this ivar Include\-Boundary is on, the subsampling will always include the boundary of the grid even though the sample rate is not an even multiple of the grid dimensions. (By default Include\-Boundary is off.)  
\item {\ttfamily int = obj.\-Get\-Include\-Boundary ()} -\/ Control whether to enforce that the \char`\"{}boundary\char`\"{} of the grid is output in the subsampling process. (This ivar only has effect when the Sample\-Rate in any direction is not equal to 1.) When this ivar Include\-Boundary is on, the subsampling will always include the boundary of the grid even though the sample rate is not an even multiple of the grid dimensions. (By default Include\-Boundary is off.)  
\item {\ttfamily obj.\-Include\-Boundary\-On ()} -\/ Control whether to enforce that the \char`\"{}boundary\char`\"{} of the grid is output in the subsampling process. (This ivar only has effect when the Sample\-Rate in any direction is not equal to 1.) When this ivar Include\-Boundary is on, the subsampling will always include the boundary of the grid even though the sample rate is not an even multiple of the grid dimensions. (By default Include\-Boundary is off.)  
\item {\ttfamily obj.\-Include\-Boundary\-Off ()} -\/ Control whether to enforce that the \char`\"{}boundary\char`\"{} of the grid is output in the subsampling process. (This ivar only has effect when the Sample\-Rate in any direction is not equal to 1.) When this ivar Include\-Boundary is on, the subsampling will always include the boundary of the grid even though the sample rate is not an even multiple of the grid dimensions. (By default Include\-Boundary is off.)  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextractselectedblock}{}\section{vtk\-Extract\-Selected\-Block}\label{vtkgraphics_vtkextractselectedblock}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
To create an instance of class vtk\-Extract\-Selected\-Block, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractSelectedBlock
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Selected\-Block has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extract\-Selected\-Block class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Selected\-Block = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Selected\-Block = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextractselectedfrustum}{}\section{vtk\-Extract\-Selected\-Frustum}\label{vtkgraphics_vtkextractselectedfrustum}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class intersects the input Data\-Set with a frustum and determines which cells and points lie within the frustum. The frustum is defined with a vtk\-Planes containing six cutting planes. The output is a Data\-Set that is either a shallow copy of the input dataset with two new \char`\"{}vtk\-Insidedness\char`\"{} attribute arrays, or a completely new Unstructured\-Grid that contains only the cells and points of the input that are inside the frustum. The Preserve\-Topology flag controls which occurs. When Preserve\-Topology is off this filter adds a scalar array called vtk\-Original\-Cell\-Ids that says what input cell produced each output cell. This is an example of a Pedigree I\-D which helps to trace back results.

To create an instance of class vtk\-Extract\-Selected\-Frustum, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractSelectedFrustum
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Selected\-Frustum has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extract\-Selected\-Frustum class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Selected\-Frustum = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Selected\-Frustum = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return the M\-Time taking into account changes to the Frustum  
\item {\ttfamily obj.\-Set\-Frustum (vtk\-Planes )} -\/ Set the selection frustum. The planes object must contain six planes.  
\item {\ttfamily vtk\-Planes = obj.\-Get\-Frustum ()} -\/ Set the selection frustum. The planes object must contain six planes.  
\item {\ttfamily obj.\-Create\-Frustum (double vertices\mbox{[}32\mbox{]})} -\/ Given eight vertices, creates a frustum. each pt is x,y,z,1 in the following order near lower left, far lower left near upper left, far upper left near lower right, far lower right near upper right, far upper right  
\item {\ttfamily vtk\-Points = obj.\-Get\-Clip\-Points ()} -\/ Return eight points that define the selection frustum. Valid if create Frustum was used, invalid if Set\-Frustum was.  
\item {\ttfamily obj.\-Set\-Field\-Type (int )} -\/ Sets/gets the intersection test type.  
\item {\ttfamily int = obj.\-Get\-Field\-Type ()} -\/ Sets/gets the intersection test type.  
\item {\ttfamily obj.\-Set\-Containing\-Cells (int )} -\/ Sets/gets the intersection test type. Only meaningful when field\-Type is vtk\-Selection\-::\-P\-O\-I\-N\-T  
\item {\ttfamily int = obj.\-Get\-Containing\-Cells ()} -\/ Sets/gets the intersection test type. Only meaningful when field\-Type is vtk\-Selection\-::\-P\-O\-I\-N\-T  
\item {\ttfamily int = obj.\-Overall\-Bounds\-Test (double bounds)} -\/ Does a quick test on the A\-A\-B\-Box defined by the bounds.  
\item {\ttfamily obj.\-Set\-Show\-Bounds (int )} -\/ When On, this returns an unstructured grid that outlines selection area. Off is the default.  
\item {\ttfamily int = obj.\-Get\-Show\-Bounds ()} -\/ When On, this returns an unstructured grid that outlines selection area. Off is the default.  
\item {\ttfamily obj.\-Show\-Bounds\-On ()} -\/ When On, this returns an unstructured grid that outlines selection area. Off is the default.  
\item {\ttfamily obj.\-Show\-Bounds\-Off ()} -\/ When On, this returns an unstructured grid that outlines selection area. Off is the default.  
\item {\ttfamily obj.\-Set\-Inside\-Out (int )} -\/ When on, extracts cells outside the frustum instead of inside.  
\item {\ttfamily int = obj.\-Get\-Inside\-Out ()} -\/ When on, extracts cells outside the frustum instead of inside.  
\item {\ttfamily obj.\-Inside\-Out\-On ()} -\/ When on, extracts cells outside the frustum instead of inside.  
\item {\ttfamily obj.\-Inside\-Out\-Off ()} -\/ When on, extracts cells outside the frustum instead of inside.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextractselectedids}{}\section{vtk\-Extract\-Selected\-Ids}\label{vtkgraphics_vtkextractselectedids}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Extract\-Selected\-Ids extracts a set of cells and points from within a vtk\-Data\-Set. The set of ids to extract are listed within a vtk\-Selection. This filter adds a scalar array called vtk\-Original\-Cell\-Ids that says what input cell produced each output cell. This is an example of a Pedigree I\-D which helps to trace back results. Depending on whether the selection has G\-L\-O\-B\-A\-L\-I\-D\-S, V\-A\-L\-U\-E\-S or I\-N\-D\-I\-C\-E\-S, the selection will use the contents of the array named in the G\-L\-O\-B\-A\-L\-I\-D\-S Data\-Set\-Attribute, and arbitrary array, or the position (tuple id or number) within the cell or point array.

To create an instance of class vtk\-Extract\-Selected\-Ids, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractSelectedIds
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Selected\-Ids has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extract\-Selected\-Ids class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Selected\-Ids = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Selected\-Ids = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextractselectedlocations}{}\section{vtk\-Extract\-Selected\-Locations}\label{vtkgraphics_vtkextractselectedlocations}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Extract\-Selected\-Locations extracts all cells whose volume contain at least one point listed in the L\-O\-C\-A\-T\-I\-O\-N\-S content of the vtk\-Selection. This filter adds a scalar array called vtk\-Original\-Cell\-Ids that says what input cell produced each output cell. This is an example of a Pedigree I\-D which helps to trace back results.

To create an instance of class vtk\-Extract\-Selected\-Locations, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractSelectedLocations
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Selected\-Locations has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extract\-Selected\-Locations class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Selected\-Locations = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Selected\-Locations = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextractselectedpolydataids}{}\section{vtk\-Extract\-Selected\-Poly\-Data\-Ids}\label{vtkgraphics_vtkextractselectedpolydataids}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Extract\-Selected\-Poly\-Data\-Ids extracts all cells in vtk\-Selection from a vtk\-Poly\-Data.

To create an instance of class vtk\-Extract\-Selected\-Poly\-Data\-Ids, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractSelectedPolyDataIds
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Selected\-Poly\-Data\-Ids has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extract\-Selected\-Poly\-Data\-Ids class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Selected\-Poly\-Data\-Ids = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Selected\-Poly\-Data\-Ids = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextractselectedrows}{}\section{vtk\-Extract\-Selected\-Rows}\label{vtkgraphics_vtkextractselectedrows}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The first input is a vtk\-Table to extract rows from. The second input is a vtk\-Selection containing the selected indices. The third input is a vtk\-Annotation\-Layers containing selected indices. The field type of the input selection is ignored when converted to row indices.

To create an instance of class vtk\-Extract\-Selected\-Rows, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractSelectedRows
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Selected\-Rows has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extract\-Selected\-Rows class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Selected\-Rows = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Selected\-Rows = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Selection\-Connection (vtk\-Algorithm\-Output in)} -\/ A convenience method for setting the second input (i.\-e. the selection).  
\item {\ttfamily obj.\-Set\-Annotation\-Layers\-Connection (vtk\-Algorithm\-Output in)} -\/ A convenience method for setting the third input (i.\-e. the annotation layers).  
\item {\ttfamily int = obj.\-Fill\-Input\-Port\-Information (int port, vtk\-Information info)} -\/ Specify the first vtk\-Graph input and the second vtk\-Selection input.  
\item {\ttfamily obj.\-Set\-Add\-Original\-Row\-Ids\-Array (bool )} -\/ When set, a column named vtk\-Original\-Row\-Ids will be added to the output. False by default.  
\item {\ttfamily bool = obj.\-Get\-Add\-Original\-Row\-Ids\-Array ()} -\/ When set, a column named vtk\-Original\-Row\-Ids will be added to the output. False by default.  
\item {\ttfamily obj.\-Add\-Original\-Row\-Ids\-Array\-On ()} -\/ When set, a column named vtk\-Original\-Row\-Ids will be added to the output. False by default.  
\item {\ttfamily obj.\-Add\-Original\-Row\-Ids\-Array\-Off ()} -\/ When set, a column named vtk\-Original\-Row\-Ids will be added to the output. False by default.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextractselectedthresholds}{}\section{vtk\-Extract\-Selected\-Thresholds}\label{vtkgraphics_vtkextractselectedthresholds}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Extract\-Selected\-Thresholds extracts all cells and points with attribute values that lie within a vtk\-Selection's T\-H\-R\-E\-S\-H\-O\-L\-D contents. The selecion can specify to threshold a particular array within either the point or cell attribute data of the input. This is similar to vtk\-Threshold but allows mutliple thresholds ranges. This filter adds a scalar array called vtk\-Original\-Cell\-Ids that says what input cell produced each output cell. This is an example of a Pedigree I\-D which helps to trace back results.

To create an instance of class vtk\-Extract\-Selected\-Thresholds, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractSelectedThresholds
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Selected\-Thresholds has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extract\-Selected\-Thresholds class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Selected\-Thresholds = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Selected\-Thresholds = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextractselection}{}\section{vtk\-Extract\-Selection}\label{vtkgraphics_vtkextractselection}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Extract\-Selection extracts some subset of cells and points from its input dataset. The dataset is given on its first input port. The subset is described by the contents of the vtk\-Selection on its second input port. Depending on the content of the vtk\-Selection, this will use either a vtk\-Extract\-Selected\-Ids, vtk\-Extract\-Selected\-Frustum vtk\-Extract\-Selected\-Locations or a vtk\-Extract\-Selected\-Threshold to perform the extraction.

To create an instance of class vtk\-Extract\-Selection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractSelection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Selection has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extract\-Selection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Selection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Selection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Show\-Bounds (int )} -\/ When On, this returns an unstructured grid that outlines selection area. Off is the default. Applicable only to Frustum selection extraction.  
\item {\ttfamily int = obj.\-Get\-Show\-Bounds ()} -\/ When On, this returns an unstructured grid that outlines selection area. Off is the default. Applicable only to Frustum selection extraction.  
\item {\ttfamily obj.\-Show\-Bounds\-On ()} -\/ When On, this returns an unstructured grid that outlines selection area. Off is the default. Applicable only to Frustum selection extraction.  
\item {\ttfamily obj.\-Show\-Bounds\-Off ()} -\/ When On, this returns an unstructured grid that outlines selection area. Off is the default. Applicable only to Frustum selection extraction.  
\item {\ttfamily obj.\-Set\-Use\-Probe\-For\-Locations (int )} -\/ When On, vtk\-Probe\-Selected\-Locations is used for extracting selections of content type vtk\-Selection\-::\-L\-O\-C\-A\-T\-I\-O\-N\-S. Default is off and then vtk\-Extract\-Selected\-Locations is used.  
\item {\ttfamily int = obj.\-Get\-Use\-Probe\-For\-Locations ()} -\/ When On, vtk\-Probe\-Selected\-Locations is used for extracting selections of content type vtk\-Selection\-::\-L\-O\-C\-A\-T\-I\-O\-N\-S. Default is off and then vtk\-Extract\-Selected\-Locations is used.  
\item {\ttfamily obj.\-Use\-Probe\-For\-Locations\-On ()} -\/ When On, vtk\-Probe\-Selected\-Locations is used for extracting selections of content type vtk\-Selection\-::\-L\-O\-C\-A\-T\-I\-O\-N\-S. Default is off and then vtk\-Extract\-Selected\-Locations is used.  
\item {\ttfamily obj.\-Use\-Probe\-For\-Locations\-Off ()} -\/ When On, vtk\-Probe\-Selected\-Locations is used for extracting selections of content type vtk\-Selection\-::\-L\-O\-C\-A\-T\-I\-O\-N\-S. Default is off and then vtk\-Extract\-Selected\-Locations is used.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextractselectionbase}{}\section{vtk\-Extract\-Selection\-Base}\label{vtkgraphics_vtkextractselectionbase}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Extract\-Selection\-Base is an abstract base class for all extract selection filters. It defines some properties common to all extract selection filters.

To create an instance of class vtk\-Extract\-Selection\-Base, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractSelectionBase
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Selection\-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\-Extract\-Selection\-Base class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Selection\-Base = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Selection\-Base = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Selection\-Connection (vtk\-Algorithm\-Output alg\-Output)} -\/ This flag tells the extraction filter not to convert the selected output into an unstructured grid, but instead to produce a vtk\-Insidedness array and add it to the input dataset. Default value is false(0).  
\item {\ttfamily obj.\-Set\-Preserve\-Topology (int )} -\/ This flag tells the extraction filter not to convert the selected output into an unstructured grid, but instead to produce a vtk\-Insidedness array and add it to the input dataset. Default value is false(0).  
\item {\ttfamily int = obj.\-Get\-Preserve\-Topology ()} -\/ This flag tells the extraction filter not to convert the selected output into an unstructured grid, but instead to produce a vtk\-Insidedness array and add it to the input dataset. Default value is false(0).  
\item {\ttfamily obj.\-Preserve\-Topology\-On ()} -\/ This flag tells the extraction filter not to convert the selected output into an unstructured grid, but instead to produce a vtk\-Insidedness array and add it to the input dataset. Default value is false(0).  
\item {\ttfamily obj.\-Preserve\-Topology\-Off ()} -\/ This flag tells the extraction filter not to convert the selected output into an unstructured grid, but instead to produce a vtk\-Insidedness array and add it to the input dataset. Default value is false(0).  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextracttemporalfielddata}{}\section{vtk\-Extract\-Temporal\-Field\-Data}\label{vtkgraphics_vtkextracttemporalfielddata}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Extract\-Temporal\-Field\-Data extracts arrays from the input vtk\-Field\-Data. These arrays are assumed to contain temporal data, where the nth tuple contains the value for the nth timestep. The output is a 1\-D rectilinear grid where the X\-Coordinates correspond to time (the same array is also copied to a point array named Time or Time\-Data (if Time exists in the input). This algorithm does not produce a T\-I\-M\-E\-\_\-\-S\-T\-E\-P\-S or T\-I\-M\-E\-\_\-\-R\-A\-N\-G\-E information because it works across time. .Section Caveat vtk\-Extract\-Temporal\-Field\-Data puts a vtk\-One\-Piece\-Extent\-Translator in the output during Request\-Information(). As a result, the same whole extented is produced independent of the piece request. This algorithm works only with source that produce T\-I\-M\-E\-\_\-\-S\-T\-E\-P\-S(). Continuous time range is not yet supported.

To create an instance of class vtk\-Extract\-Temporal\-Field\-Data, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractTemporalFieldData
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Temporal\-Field\-Data has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extract\-Temporal\-Field\-Data class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Temporal\-Field\-Data = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Temporal\-Field\-Data = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Time\-Steps ()} -\/ Get the number of time steps  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextracttensorcomponents}{}\section{vtk\-Extract\-Tensor\-Components}\label{vtkgraphics_vtkextracttensorcomponents}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Extract\-Tensor\-Components is a filter that extracts components of a tensor to create a scalar, vector, normal, or texture coords. For example, if the tensor contains components of stress, then you could extract the normal stress in the x-\/direction as a scalar (i.\-e., tensor component (0,0).

To use this filter, you must set some boolean flags to control which data is extracted from the tensors, and whether you want to pass the tensor data through to the output. Also, you must specify the tensor component(s) for each type of data you want to extract. The tensor component(s) is(are) specified using matrix notation into a 3x3 matrix. That is, use the (row,column) address to specify a particular tensor component; and if the data you are extracting requires more than one component, use a list of addresses. (Note that the addresses are 0-\/offset -\/$>$ (0,0) specifies upper left corner of the tensor.)

There are two optional methods to extract scalar data. You can extract the determinant of the tensor, or you can extract the effective stress of the tensor. These require that the ivar Extract\-Scalars is on, and the appropriate scalar extraction mode is set.

To create an instance of class vtk\-Extract\-Tensor\-Components, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractTensorComponents
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Tensor\-Components has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extract\-Tensor\-Components class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Tensor\-Components = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Tensor\-Components = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Pass\-Tensors\-To\-Output (int )} -\/ Boolean controls whether tensor data is passed through to output.  
\item {\ttfamily int = obj.\-Get\-Pass\-Tensors\-To\-Output ()} -\/ Boolean controls whether tensor data is passed through to output.  
\item {\ttfamily obj.\-Pass\-Tensors\-To\-Output\-On ()} -\/ Boolean controls whether tensor data is passed through to output.  
\item {\ttfamily obj.\-Pass\-Tensors\-To\-Output\-Off ()} -\/ Boolean controls whether tensor data is passed through to output.  
\item {\ttfamily obj.\-Set\-Extract\-Scalars (int )} -\/ Boolean controls whether scalar data is extracted from tensor.  
\item {\ttfamily int = obj.\-Get\-Extract\-Scalars ()} -\/ Boolean controls whether scalar data is extracted from tensor.  
\item {\ttfamily obj.\-Extract\-Scalars\-On ()} -\/ Boolean controls whether scalar data is extracted from tensor.  
\item {\ttfamily obj.\-Extract\-Scalars\-Off ()} -\/ Boolean controls whether scalar data is extracted from tensor.  
\item {\ttfamily obj.\-Set\-Scalar\-Components (int , int )} -\/ Specify the (row,column) tensor component to extract as a scalar.  
\item {\ttfamily obj.\-Set\-Scalar\-Components (int a\mbox{[}2\mbox{]})} -\/ Specify the (row,column) tensor component to extract as a scalar.  
\item {\ttfamily int = obj. Get\-Scalar\-Components ()} -\/ Specify the (row,column) tensor component to extract as a scalar.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode (int )} -\/ Specify how to extract the scalar. You can extract it as one of the components of the tensor, as effective stress, or as the determinant of the tensor. If you extract a component make sure that you set the Scalar\-Components ivar.  
\item {\ttfamily int = obj.\-Get\-Scalar\-Mode ()} -\/ Specify how to extract the scalar. You can extract it as one of the components of the tensor, as effective stress, or as the determinant of the tensor. If you extract a component make sure that you set the Scalar\-Components ivar.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Component ()} -\/ Specify how to extract the scalar. You can extract it as one of the components of the tensor, as effective stress, or as the determinant of the tensor. If you extract a component make sure that you set the Scalar\-Components ivar.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Effective\-Stress ()} -\/ Specify how to extract the scalar. You can extract it as one of the components of the tensor, as effective stress, or as the determinant of the tensor. If you extract a component make sure that you set the Scalar\-Components ivar.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Determinant ()} -\/ Specify how to extract the scalar. You can extract it as one of the components of the tensor, as effective stress, or as the determinant of the tensor. If you extract a component make sure that you set the Scalar\-Components ivar.  
\item {\ttfamily obj.\-Scalar\-Is\-Component ()} -\/ Specify how to extract the scalar. You can extract it as one of the components of the tensor, as effective stress, or as the determinant of the tensor. If you extract a component make sure that you set the Scalar\-Components ivar.  
\item {\ttfamily obj.\-Scalar\-Is\-Effective\-Stress ()} -\/ Specify how to extract the scalar. You can extract it as one of the components of the tensor, as effective stress, or as the determinant of the tensor. If you extract a component make sure that you set the Scalar\-Components ivar.  
\item {\ttfamily obj.\-Scalar\-Is\-Determinant ()} -\/ Specify how to extract the scalar. You can extract it as one of the components of the tensor, as effective stress, or as the determinant of the tensor. If you extract a component make sure that you set the Scalar\-Components ivar.  
\item {\ttfamily obj.\-Set\-Extract\-Vectors (int )} -\/ Boolean controls whether vector data is extracted from tensor.  
\item {\ttfamily int = obj.\-Get\-Extract\-Vectors ()} -\/ Boolean controls whether vector data is extracted from tensor.  
\item {\ttfamily obj.\-Extract\-Vectors\-On ()} -\/ Boolean controls whether vector data is extracted from tensor.  
\item {\ttfamily obj.\-Extract\-Vectors\-Off ()} -\/ Boolean controls whether vector data is extracted from tensor.  
\item {\ttfamily obj.\-Set\-Vector\-Components (int , int , int , int , int , int )} -\/ Specify the ((row,column)0,(row,column)1,(row,column)2) tensor components to extract as a vector.  
\item {\ttfamily obj.\-Set\-Vector\-Components (int a\mbox{[}6\mbox{]})} -\/ Specify the ((row,column)0,(row,column)1,(row,column)2) tensor components to extract as a vector.  
\item {\ttfamily int = obj. Get\-Vector\-Components ()} -\/ Specify the ((row,column)0,(row,column)1,(row,column)2) tensor components to extract as a vector.  
\item {\ttfamily obj.\-Set\-Extract\-Normals (int )} -\/ Boolean controls whether normal data is extracted from tensor.  
\item {\ttfamily int = obj.\-Get\-Extract\-Normals ()} -\/ Boolean controls whether normal data is extracted from tensor.  
\item {\ttfamily obj.\-Extract\-Normals\-On ()} -\/ Boolean controls whether normal data is extracted from tensor.  
\item {\ttfamily obj.\-Extract\-Normals\-Off ()} -\/ Boolean controls whether normal data is extracted from tensor.  
\item {\ttfamily obj.\-Set\-Normalize\-Normals (int )} -\/ Boolean controls whether normal vector is converted to unit normal after extraction.  
\item {\ttfamily int = obj.\-Get\-Normalize\-Normals ()} -\/ Boolean controls whether normal vector is converted to unit normal after extraction.  
\item {\ttfamily obj.\-Normalize\-Normals\-On ()} -\/ Boolean controls whether normal vector is converted to unit normal after extraction.  
\item {\ttfamily obj.\-Normalize\-Normals\-Off ()} -\/ Boolean controls whether normal vector is converted to unit normal after extraction.  
\item {\ttfamily obj.\-Set\-Normal\-Components (int , int , int , int , int , int )} -\/ Specify the ((row,column)0,(row,column)1,(row,column)2) tensor components to extract as a vector.  
\item {\ttfamily obj.\-Set\-Normal\-Components (int a\mbox{[}6\mbox{]})} -\/ Specify the ((row,column)0,(row,column)1,(row,column)2) tensor components to extract as a vector.  
\item {\ttfamily int = obj. Get\-Normal\-Components ()} -\/ Specify the ((row,column)0,(row,column)1,(row,column)2) tensor components to extract as a vector.  
\item {\ttfamily obj.\-Set\-Extract\-T\-Coords (int )} -\/ Boolean controls whether texture coordinates are extracted from tensor.  
\item {\ttfamily int = obj.\-Get\-Extract\-T\-Coords ()} -\/ Boolean controls whether texture coordinates are extracted from tensor.  
\item {\ttfamily obj.\-Extract\-T\-Coords\-On ()} -\/ Boolean controls whether texture coordinates are extracted from tensor.  
\item {\ttfamily obj.\-Extract\-T\-Coords\-Off ()} -\/ Boolean controls whether texture coordinates are extracted from tensor.  
\item {\ttfamily obj.\-Set\-Number\-Of\-T\-Coords (int )} -\/ Set the dimension of the texture coordinates to extract.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-T\-Coords\-Min\-Value ()} -\/ Set the dimension of the texture coordinates to extract.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-T\-Coords\-Max\-Value ()} -\/ Set the dimension of the texture coordinates to extract.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-T\-Coords ()} -\/ Set the dimension of the texture coordinates to extract.  
\item {\ttfamily obj.\-Set\-T\-Coord\-Components (int , int , int , int , int , int )} -\/ Specify the ((row,column)0,(row,column)1,(row,column)2) tensor components to extract as a vector. Up to Number\-Of\-T\-Coords components are extracted.  
\item {\ttfamily obj.\-Set\-T\-Coord\-Components (int a\mbox{[}6\mbox{]})} -\/ Specify the ((row,column)0,(row,column)1,(row,column)2) tensor components to extract as a vector. Up to Number\-Of\-T\-Coords components are extracted.  
\item {\ttfamily int = obj. Get\-T\-Coord\-Components ()} -\/ Specify the ((row,column)0,(row,column)1,(row,column)2) tensor components to extract as a vector. Up to Number\-Of\-T\-Coords components are extracted.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextractunstructuredgrid}{}\section{vtk\-Extract\-Unstructured\-Grid}\label{vtkgraphics_vtkextractunstructuredgrid}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Extract\-Unstructured\-Grid is a general-\/purpose filter to extract geometry (and associated data) from an unstructured grid dataset. The extraction process is controlled by specifying a range of point ids, cell ids, or a bounding box (referred to as \char`\"{}\-Extent\char`\"{}). Those cells lying within these regions are sent to the output. The user has the choice of merging coincident points (Merging is on) or using the original point set (Merging is off).

To create an instance of class vtk\-Extract\-Unstructured\-Grid, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractUnstructuredGrid
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Unstructured\-Grid has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extract\-Unstructured\-Grid class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Unstructured\-Grid = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Unstructured\-Grid = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Point\-Clipping (int )} -\/ Turn on/off selection of geometry by point id.  
\item {\ttfamily int = obj.\-Get\-Point\-Clipping ()} -\/ Turn on/off selection of geometry by point id.  
\item {\ttfamily obj.\-Point\-Clipping\-On ()} -\/ Turn on/off selection of geometry by point id.  
\item {\ttfamily obj.\-Point\-Clipping\-Off ()} -\/ Turn on/off selection of geometry by point id.  
\item {\ttfamily obj.\-Set\-Cell\-Clipping (int )} -\/ Turn on/off selection of geometry by cell id.  
\item {\ttfamily int = obj.\-Get\-Cell\-Clipping ()} -\/ Turn on/off selection of geometry by cell id.  
\item {\ttfamily obj.\-Cell\-Clipping\-On ()} -\/ Turn on/off selection of geometry by cell id.  
\item {\ttfamily obj.\-Cell\-Clipping\-Off ()} -\/ Turn on/off selection of geometry by cell id.  
\item {\ttfamily obj.\-Set\-Extent\-Clipping (int )} -\/ Turn on/off selection of geometry via bounding box.  
\item {\ttfamily int = obj.\-Get\-Extent\-Clipping ()} -\/ Turn on/off selection of geometry via bounding box.  
\item {\ttfamily obj.\-Extent\-Clipping\-On ()} -\/ Turn on/off selection of geometry via bounding box.  
\item {\ttfamily obj.\-Extent\-Clipping\-Off ()} -\/ Turn on/off selection of geometry via bounding box.  
\item {\ttfamily obj.\-Set\-Point\-Minimum (vtk\-Id\-Type )} -\/ Specify the minimum point id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Point\-Minimum\-Min\-Value ()} -\/ Specify the minimum point id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Point\-Minimum\-Max\-Value ()} -\/ Specify the minimum point id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Point\-Minimum ()} -\/ Specify the minimum point id for point id selection.  
\item {\ttfamily obj.\-Set\-Point\-Maximum (vtk\-Id\-Type )} -\/ Specify the maximum point id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Point\-Maximum\-Min\-Value ()} -\/ Specify the maximum point id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Point\-Maximum\-Max\-Value ()} -\/ Specify the maximum point id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Point\-Maximum ()} -\/ Specify the maximum point id for point id selection.  
\item {\ttfamily obj.\-Set\-Cell\-Minimum (vtk\-Id\-Type )} -\/ Specify the minimum cell id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Cell\-Minimum\-Min\-Value ()} -\/ Specify the minimum cell id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Cell\-Minimum\-Max\-Value ()} -\/ Specify the minimum cell id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Cell\-Minimum ()} -\/ Specify the minimum cell id for point id selection.  
\item {\ttfamily obj.\-Set\-Cell\-Maximum (vtk\-Id\-Type )} -\/ Specify the maximum cell id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Cell\-Maximum\-Min\-Value ()} -\/ Specify the maximum cell id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Cell\-Maximum\-Max\-Value ()} -\/ Specify the maximum cell id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Cell\-Maximum ()} -\/ Specify the maximum cell id for point id selection.  
\item {\ttfamily obj.\-Set\-Extent (double x\-Min, double x\-Max, double y\-Min, double y\-Max, double z\-Min, double z\-Max)} -\/ Specify a (xmin,xmax, ymin,ymax, zmin,zmax) bounding box to clip data.  
\item {\ttfamily obj.\-Set\-Extent (double extent\mbox{[}6\mbox{]})} -\/ Set / get a (xmin,xmax, ymin,ymax, zmin,zmax) bounding box to clip data.  
\item {\ttfamily double = obj.\-Get\-Extent ()} -\/ Set / get a (xmin,xmax, ymin,ymax, zmin,zmax) bounding box to clip data.  
\item {\ttfamily obj.\-Set\-Merging (int )} -\/ Turn on/off merging of coincident points. Note that is merging is on, points with different point attributes (e.\-g., normals) are merged, which may cause rendering artifacts.  
\item {\ttfamily int = obj.\-Get\-Merging ()} -\/ Turn on/off merging of coincident points. Note that is merging is on, points with different point attributes (e.\-g., normals) are merged, which may cause rendering artifacts.  
\item {\ttfamily obj.\-Merging\-On ()} -\/ Turn on/off merging of coincident points. Note that is merging is on, points with different point attributes (e.\-g., normals) are merged, which may cause rendering artifacts.  
\item {\ttfamily obj.\-Merging\-Off ()} -\/ Turn on/off merging of coincident points. Note that is merging is on, points with different point attributes (e.\-g., normals) are merged, which may cause rendering artifacts.  
\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 M\-Time also considering the locator.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkextractvectorcomponents}{}\section{vtk\-Extract\-Vector\-Components}\label{vtkgraphics_vtkextractvectorcomponents}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Extract\-Vector\-Components is a filter that extracts vector components as separate scalars. This is accomplished by creating three different outputs. Each output is the same as the input, except that the scalar values will be one of the three components of the vector. These can be found in the Vx\-Component, Vy\-Component, and Vz\-Component. Alternatively, if the Extract\-To\-Field\-Data flag is set, the filter will put all the components in the field data. The first component will be the scalar and the others will be non-\/attribute arrays.

To create an instance of class vtk\-Extract\-Vector\-Components, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractVectorComponents
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-Vector\-Components has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Extract\-Vector\-Components class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-Vector\-Components = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-Vector\-Components = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Input (vtk\-Data\-Set input)} -\/ Specify the input data or filter.  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Vx\-Component ()} -\/ Get the output dataset representing velocity x-\/component. If output is N\-U\-L\-L then input hasn't been set, which is necessary for abstract objects. (Note\-: this method returns the same information as the Get\-Output() method with an index of 0.)  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Vy\-Component ()} -\/ Get the output dataset representing velocity y-\/component. If output is N\-U\-L\-L then input hasn't been set, which is necessary for abstract objects. (Note\-: this method returns the same information as the Get\-Output() method with an index of 1.) Note that if Extract\-To\-Field\-Data is true, this output will be empty.  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Vz\-Component ()} -\/ Get the output dataset representing velocity z-\/component. If output is N\-U\-L\-L then input hasn't been set, which is necessary for abstract objects. (Note\-: this method returns the same information as the Get\-Output() method with an index of 2.) Note that if Extract\-To\-Field\-Data is true, this output will be empty.  
\item {\ttfamily obj.\-Set\-Extract\-To\-Field\-Data (int )} -\/ Determines whether the vector components will be put in separate outputs or in the first output's field data  
\item {\ttfamily int = obj.\-Get\-Extract\-To\-Field\-Data ()} -\/ Determines whether the vector components will be put in separate outputs or in the first output's field data  
\item {\ttfamily obj.\-Extract\-To\-Field\-Data\-On ()} -\/ Determines whether the vector components will be put in separate outputs or in the first output's field data  
\item {\ttfamily obj.\-Extract\-To\-Field\-Data\-Off ()} -\/ Determines whether the vector components will be put in separate outputs or in the first output's field data  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkfeatureedges}{}\section{vtk\-Feature\-Edges}\label{vtkgraphics_vtkfeatureedges}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Feature\-Edges is a filter to extract special types of edges from input polygonal data. These edges are either 1) boundary (used by one polygon) or a line cell; 2) non-\/manifold (used by three or more polygons); 3) feature edges (edges used by two triangles and whose dihedral angle $>$ Feature\-Angle); or 4) manifold edges (edges used by exactly two polygons). These edges may be extracted in any combination. Edges may also be \char`\"{}colored\char`\"{} (i.\-e., scalar values assigned) based on edge type. The cell coloring is assigned to the cell data of the extracted edges.

To create an instance of class vtk\-Feature\-Edges, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFeatureEdges
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Feature\-Edges has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Feature\-Edges class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Feature\-Edges = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Feature\-Edges = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Boundary\-Edges (int )} -\/ Turn on/off the extraction of boundary edges.  
\item {\ttfamily int = obj.\-Get\-Boundary\-Edges ()} -\/ Turn on/off the extraction of boundary edges.  
\item {\ttfamily obj.\-Boundary\-Edges\-On ()} -\/ Turn on/off the extraction of boundary edges.  
\item {\ttfamily obj.\-Boundary\-Edges\-Off ()} -\/ Turn on/off the extraction of boundary edges.  
\item {\ttfamily obj.\-Set\-Feature\-Edges (int )} -\/ Turn on/off the extraction of feature edges.  
\item {\ttfamily int = obj.\-Get\-Feature\-Edges ()} -\/ Turn on/off the extraction of feature edges.  
\item {\ttfamily obj.\-Feature\-Edges\-On ()} -\/ Turn on/off the extraction of feature edges.  
\item {\ttfamily obj.\-Feature\-Edges\-Off ()} -\/ Turn on/off the extraction of feature edges.  
\item {\ttfamily obj.\-Set\-Feature\-Angle (double )} -\/ Specify the feature angle for extracting feature edges.  
\item {\ttfamily double = obj.\-Get\-Feature\-Angle\-Min\-Value ()} -\/ Specify the feature angle for extracting feature edges.  
\item {\ttfamily double = obj.\-Get\-Feature\-Angle\-Max\-Value ()} -\/ Specify the feature angle for extracting feature edges.  
\item {\ttfamily double = obj.\-Get\-Feature\-Angle ()} -\/ Specify the feature angle for extracting feature edges.  
\item {\ttfamily obj.\-Set\-Non\-Manifold\-Edges (int )} -\/ Turn on/off the extraction of non-\/manifold edges.  
\item {\ttfamily int = obj.\-Get\-Non\-Manifold\-Edges ()} -\/ Turn on/off the extraction of non-\/manifold edges.  
\item {\ttfamily obj.\-Non\-Manifold\-Edges\-On ()} -\/ Turn on/off the extraction of non-\/manifold edges.  
\item {\ttfamily obj.\-Non\-Manifold\-Edges\-Off ()} -\/ Turn on/off the extraction of non-\/manifold edges.  
\item {\ttfamily obj.\-Set\-Manifold\-Edges (int )} -\/ Turn on/off the extraction of manifold edges.  
\item {\ttfamily int = obj.\-Get\-Manifold\-Edges ()} -\/ Turn on/off the extraction of manifold edges.  
\item {\ttfamily obj.\-Manifold\-Edges\-On ()} -\/ Turn on/off the extraction of manifold edges.  
\item {\ttfamily obj.\-Manifold\-Edges\-Off ()} -\/ Turn on/off the extraction of manifold edges.  
\item {\ttfamily obj.\-Set\-Coloring (int )} -\/ Turn on/off the coloring of edges by type.  
\item {\ttfamily int = obj.\-Get\-Coloring ()} -\/ Turn on/off the coloring of edges by type.  
\item {\ttfamily obj.\-Coloring\-On ()} -\/ Turn on/off the coloring of edges by type.  
\item {\ttfamily obj.\-Coloring\-Off ()} -\/ Turn on/off the coloring of edges by type.  
\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 M\-Time also considering the locator.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkfielddatatoattributedatafilter}{}\section{vtk\-Field\-Data\-To\-Attribute\-Data\-Filter}\label{vtkgraphics_vtkfielddatatoattributedatafilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Field\-Data\-To\-Attribute\-Data\-Filter is a class that maps field data into dataset attributes. The input to this filter is any type of dataset and the output is the same dataset (geometry/topology) with new attribute data (attribute data is passed through if not replaced during filter execution).

To use this filter you must specify which field data from the input dataset to use. There are three possibilities\-: the cell field data, the point field data, or the field data associated with the data object superclass. Then you specify which attribute data to create\-: either cell attribute data or point attribute data. Finally, you must define how to construct the various attribute data types (e.\-g., scalars, vectors, normals, etc.) from the arrays and the components of the arrays from the field data. This is done by associating components in the input field with components making up the attribute data. For example, you would specify a scalar with three components (R\-G\-B) by assigning components from the field for the R, then G, then B values of the scalars. You may also have to specify component ranges (for each R-\/\-G-\/\-B) to make sure that the number of R, G, and B values is the same. Also, you may want to normalize the components which helps distribute the data uniformly.

This filter is often used in conjunction with vtk\-Data\-Object\-To\-Data\-Set\-Filter. vtk\-Data\-Object\-To\-Data\-Set\-Filter filter generates dataset topology and geometry and passes its input field data along to its output. Then this filter is used to generate the attribute data to go along with the dataset.

To create an instance of class vtk\-Field\-Data\-To\-Attribute\-Data\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFieldDataToAttributeDataFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Field\-Data\-To\-Attribute\-Data\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Field\-Data\-To\-Attribute\-Data\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Field\-Data\-To\-Attribute\-Data\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Field\-Data\-To\-Attribute\-Data\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Input\-Field (int )} -\/ Specify which field data to use to generate the output attribute data. There are three choices\-: the field data associated with the vtk\-Data\-Object superclass; the point field attribute data; and the cell field attribute data.  
\item {\ttfamily int = obj.\-Get\-Input\-Field ()} -\/ Specify which field data to use to generate the output attribute data. There are three choices\-: the field data associated with the vtk\-Data\-Object superclass; the point field attribute data; and the cell field attribute data.  
\item {\ttfamily obj.\-Set\-Input\-Field\-To\-Data\-Object\-Field ()} -\/ Specify which field data to use to generate the output attribute data. There are three choices\-: the field data associated with the vtk\-Data\-Object superclass; the point field attribute data; and the cell field attribute data.  
\item {\ttfamily obj.\-Set\-Input\-Field\-To\-Point\-Data\-Field ()} -\/ Specify which field data to use to generate the output attribute data. There are three choices\-: the field data associated with the vtk\-Data\-Object superclass; the point field attribute data; and the cell field attribute data.  
\item {\ttfamily obj.\-Set\-Input\-Field\-To\-Cell\-Data\-Field ()} -\/ Specify which field data to use to generate the output attribute data. There are three choices\-: the field data associated with the vtk\-Data\-Object superclass; the point field attribute data; and the cell field attribute data.  
\item {\ttfamily obj.\-Set\-Output\-Attribute\-Data (int )} -\/ Specify which attribute data to output\-: point or cell data attributes.  
\item {\ttfamily int = obj.\-Get\-Output\-Attribute\-Data ()} -\/ Specify which attribute data to output\-: point or cell data attributes.  
\item {\ttfamily obj.\-Set\-Output\-Attribute\-Data\-To\-Cell\-Data ()} -\/ Specify which attribute data to output\-: point or cell data attributes.  
\item {\ttfamily obj.\-Set\-Output\-Attribute\-Data\-To\-Point\-Data ()} -\/ Specify which attribute data to output\-: point or cell data attributes.  
\item {\ttfamily obj.\-Set\-Scalar\-Component (int comp, string array\-Name, int array\-Comp, int min, int max, int normalize)} -\/ Define the component(s) of the field to be used for the scalar components. Note that the parameter comp must lie between (0,4). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily obj.\-Set\-Scalar\-Component (int comp, string array\-Name, int array\-Comp)} -\/ Define the component(s) of the field to be used for the scalar components. Note that the parameter comp must lie between (0,4). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily string = obj.\-Get\-Scalar\-Component\-Array\-Name (int comp)} -\/ Define the component(s) of the field to be used for the scalar components. Note that the parameter comp must lie between (0,4). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily int = obj.\-Get\-Scalar\-Component\-Array\-Component (int comp)} -\/ Define the component(s) of the field to be used for the scalar components. Note that the parameter comp must lie between (0,4). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily int = obj.\-Get\-Scalar\-Component\-Min\-Range (int comp)} -\/ Define the component(s) of the field to be used for the scalar components. Note that the parameter comp must lie between (0,4). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily int = obj.\-Get\-Scalar\-Component\-Max\-Range (int comp)} -\/ Define the component(s) of the field to be used for the scalar components. Note that the parameter comp must lie between (0,4). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily int = obj.\-Get\-Scalar\-Component\-Normalize\-Flag (int comp)} -\/ Define the component(s) of the field to be used for the scalar components. Note that the parameter comp must lie between (0,4). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily obj.\-Set\-Vector\-Component (int comp, string array\-Name, int array\-Comp, int min, int max, int normalize)} -\/ Define the component(s) of the field to be used for the vector components. Note that the parameter comp must lie between (0,3). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily obj.\-Set\-Vector\-Component (int comp, string array\-Name, int array\-Comp)} -\/ Define the component(s) of the field to be used for the vector components. Note that the parameter comp must lie between (0,3). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily string = obj.\-Get\-Vector\-Component\-Array\-Name (int comp)} -\/ Define the component(s) of the field to be used for the vector components. Note that the parameter comp must lie between (0,3). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily int = obj.\-Get\-Vector\-Component\-Array\-Component (int comp)} -\/ Define the component(s) of the field to be used for the vector components. Note that the parameter comp must lie between (0,3). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily int = obj.\-Get\-Vector\-Component\-Min\-Range (int comp)} -\/ Define the component(s) of the field to be used for the vector components. Note that the parameter comp must lie between (0,3). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily int = obj.\-Get\-Vector\-Component\-Max\-Range (int comp)} -\/ Define the component(s) of the field to be used for the vector components. Note that the parameter comp must lie between (0,3). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily int = obj.\-Get\-Vector\-Component\-Normalize\-Flag (int comp)} -\/ Define the component(s) of the field to be used for the vector components. Note that the parameter comp must lie between (0,3). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily obj.\-Set\-Normal\-Component (int comp, string array\-Name, int array\-Comp, int min, int max, int normalize)} -\/ Define the component(s) of the field to be used for the normal components. Note that the parameter comp must lie between (0,3). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily obj.\-Set\-Normal\-Component (int comp, string array\-Name, int array\-Comp)} -\/ Define the component(s) of the field to be used for the normal components. Note that the parameter comp must lie between (0,3). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily string = obj.\-Get\-Normal\-Component\-Array\-Name (int comp)} -\/ Define the component(s) of the field to be used for the normal components. Note that the parameter comp must lie between (0,3). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily int = obj.\-Get\-Normal\-Component\-Array\-Component (int comp)} -\/ Define the component(s) of the field to be used for the normal components. Note that the parameter comp must lie between (0,3). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily int = obj.\-Get\-Normal\-Component\-Min\-Range (int comp)} -\/ Define the component(s) of the field to be used for the normal components. Note that the parameter comp must lie between (0,3). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily int = obj.\-Get\-Normal\-Component\-Max\-Range (int comp)} -\/ Define the component(s) of the field to be used for the normal components. Note that the parameter comp must lie between (0,3). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily int = obj.\-Get\-Normal\-Component\-Normalize\-Flag (int comp)} -\/ Define the component(s) of the field to be used for the normal components. Note that the parameter comp must lie between (0,3). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily obj.\-Set\-Tensor\-Component (int comp, string array\-Name, int array\-Comp, int min, int max, int normalize)} -\/ Define the components of the field to be used for the tensor components. Note that the parameter comp must lie between (0,9). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily obj.\-Set\-Tensor\-Component (int comp, string array\-Name, int array\-Comp)} -\/ Define the components of the field to be used for the tensor components. Note that the parameter comp must lie between (0,9). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily string = obj.\-Get\-Tensor\-Component\-Array\-Name (int comp)} -\/ Define the components of the field to be used for the tensor components. Note that the parameter comp must lie between (0,9). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily int = obj.\-Get\-Tensor\-Component\-Array\-Component (int comp)} -\/ Define the components of the field to be used for the tensor components. Note that the parameter comp must lie between (0,9). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily int = obj.\-Get\-Tensor\-Component\-Min\-Range (int comp)} -\/ Define the components of the field to be used for the tensor components. Note that the parameter comp must lie between (0,9). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily int = obj.\-Get\-Tensor\-Component\-Max\-Range (int comp)} -\/ Define the components of the field to be used for the tensor components. Note that the parameter comp must lie between (0,9). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily int = obj.\-Get\-Tensor\-Component\-Normalize\-Flag (int comp)} -\/ Define the components of the field to be used for the tensor components. Note that the parameter comp must lie between (0,9). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily obj.\-Set\-T\-Coord\-Component (int comp, string array\-Name, int array\-Comp, int min, int max, int normalize)} -\/ Define the components of the field to be used for the cell texture coord components. Note that the parameter comp must lie between (0,9). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily obj.\-Set\-T\-Coord\-Component (int comp, string array\-Name, int array\-Comp)} -\/ Define the components of the field to be used for the cell texture coord components. Note that the parameter comp must lie between (0,9). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily string = obj.\-Get\-T\-Coord\-Component\-Array\-Name (int comp)} -\/ Define the components of the field to be used for the cell texture coord components. Note that the parameter comp must lie between (0,9). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily int = obj.\-Get\-T\-Coord\-Component\-Array\-Component (int comp)} -\/ Define the components of the field to be used for the cell texture coord components. Note that the parameter comp must lie between (0,9). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily int = obj.\-Get\-T\-Coord\-Component\-Min\-Range (int comp)} -\/ Define the components of the field to be used for the cell texture coord components. Note that the parameter comp must lie between (0,9). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily int = obj.\-Get\-T\-Coord\-Component\-Max\-Range (int comp)} -\/ Define the components of the field to be used for the cell texture coord components. Note that the parameter comp must lie between (0,9). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily int = obj.\-Get\-T\-Coord\-Component\-Normalize\-Flag (int comp)} -\/ Define the components of the field to be used for the cell texture coord components. Note that the parameter comp must lie between (0,9). To define the field component to use you specify an array name and the component in that array. The (min,max) values are the range of data in the component you wish to extract.  
\item {\ttfamily obj.\-Set\-Default\-Normalize (int )} -\/ Set the default Normalize() flag for those methods setting a default Normalize value (e.\-g., Set\-Scalar\-Components).  
\item {\ttfamily int = obj.\-Get\-Default\-Normalize ()} -\/ Set the default Normalize() flag for those methods setting a default Normalize value (e.\-g., Set\-Scalar\-Components).  
\item {\ttfamily obj.\-Default\-Normalize\-On ()} -\/ Set the default Normalize() flag for those methods setting a default Normalize value (e.\-g., Set\-Scalar\-Components).  
\item {\ttfamily obj.\-Default\-Normalize\-Off ()} -\/ Set the default Normalize() flag for those methods setting a default Normalize value (e.\-g., Set\-Scalar\-Components).  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkfillholesfilter}{}\section{vtk\-Fill\-Holes\-Filter}\label{vtkgraphics_vtkfillholesfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Fill\-Holes\-Filter is a filter that identifies and fills holes in input vtk\-Poly\-Data meshes. Holes are identified by locating boundary edges, linking them together into loops, and then triangulating the resulting loops. Note that you can specify an approximate limit to the size of the hole that can be filled.

To create an instance of class vtk\-Fill\-Holes\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFillHolesFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Fill\-Holes\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Fill\-Holes\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instantiation, type information and printing.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instantiation, type information and printing.  
\item {\ttfamily vtk\-Fill\-Holes\-Filter = obj.\-New\-Instance ()} -\/ Standard methods for instantiation, type information and printing.  
\item {\ttfamily vtk\-Fill\-Holes\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instantiation, type information and printing.  
\item {\ttfamily obj.\-Set\-Hole\-Size (double )} -\/ Specify the maximum hole size to fill. This is represented as a radius to the bounding circumsphere containing the hole. Note that this is an approximate area; the actual area cannot be computed without first triangulating the hole.  
\item {\ttfamily double = obj.\-Get\-Hole\-Size\-Min\-Value ()} -\/ Specify the maximum hole size to fill. This is represented as a radius to the bounding circumsphere containing the hole. Note that this is an approximate area; the actual area cannot be computed without first triangulating the hole.  
\item {\ttfamily double = obj.\-Get\-Hole\-Size\-Max\-Value ()} -\/ Specify the maximum hole size to fill. This is represented as a radius to the bounding circumsphere containing the hole. Note that this is an approximate area; the actual area cannot be computed without first triangulating the hole.  
\item {\ttfamily double = obj.\-Get\-Hole\-Size ()} -\/ Specify the maximum hole size to fill. This is represented as a radius to the bounding circumsphere containing the hole. Note that this is an approximate area; the actual area cannot be computed without first triangulating the hole.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkfrustumsource}{}\section{vtk\-Frustum\-Source}\label{vtkgraphics_vtkfrustumsource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Frustum\-Source creates a frustum defines by a set of planes. The frustum is represented with four-\/sided polygons. It is possible to specify extra lines to better visualize the field of view.

.S\-E\-C\-T\-I\-O\-N Usage Typical use consists of 3 steps\-:
\begin{DoxyEnumerate}
\item get the planes coefficients from a vtk\-Camera with vtk\-Camera\-::\-Get\-Frustum\-Planes()
\item initialize the planes with vtk\-Planes\-::\-Set\-Frustum\-Planes() with the planes coefficients
\item pass the vtk\-Planes to a vtk\-Frustum\-Source.
\end{DoxyEnumerate}

To create an instance of class vtk\-Frustum\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFrustumSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Frustum\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Frustum\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Frustum\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Frustum\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Planes = obj.\-Get\-Planes ()} -\/ Return the 6 planes defining the frustum. Initial value is N\-U\-L\-L. The 6 planes are defined in this order\-: left,right,bottom,top,far,near. If Planes==N\-U\-L\-L or if Planes-\/$>$Get\-Number\-Of\-Planes()!=6 when Request\-Data() is called, an error message will be emitted and Request\-Data() will return right away.  
\item {\ttfamily obj.\-Set\-Planes (vtk\-Planes planes)} -\/ Set the 6 planes defining the frustum.  
\item {\ttfamily bool = obj.\-Get\-Show\-Lines ()} -\/ Tells if some extra lines will be generated. Initial value is true.  
\item {\ttfamily obj.\-Set\-Show\-Lines (bool )} -\/ Tells if some extra lines will be generated. Initial value is true.  
\item {\ttfamily obj.\-Show\-Lines\-On ()} -\/ Tells if some extra lines will be generated. Initial value is true.  
\item {\ttfamily obj.\-Show\-Lines\-Off ()} -\/ Tells if some extra lines will be generated. Initial value is true.  
\item {\ttfamily double = obj.\-Get\-Lines\-Length ()} -\/ Length of the extra lines. This a stricly positive value. Initial value is 1.\-0.  
\item {\ttfamily obj.\-Set\-Lines\-Length (double )} -\/ Length of the extra lines. This a stricly positive value. Initial value is 1.\-0.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Modified Get\-M\-Time because of Planes.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkgeodesicpath}{}\section{vtk\-Geodesic\-Path}\label{vtkgraphics_vtkgeodesicpath}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Serves as a base class for algorithms that trace a geodesic path on a polygonal dataset.

To create an instance of class vtk\-Geodesic\-Path, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGeodesicPath
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Geodesic\-Path has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Geodesic\-Path class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methids for printing and determining type information.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methids for printing and determining type information.  
\item {\ttfamily vtk\-Geodesic\-Path = obj.\-New\-Instance ()} -\/ Standard methids for printing and determining type information.  
\item {\ttfamily vtk\-Geodesic\-Path = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methids for printing and determining type information.  
\item {\ttfamily double = obj.\-Get\-Geodesic\-Length ()}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkgeometryfilter}{}\section{vtk\-Geometry\-Filter}\label{vtkgraphics_vtkgeometryfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Geometry\-Filter is a general-\/purpose filter to extract geometry (and associated data) from any type of dataset. Geometry is obtained as follows\-: all 0\-D, 1\-D, and 2\-D cells are extracted. All 2\-D faces that are used by only one 3\-D cell (i.\-e., boundary faces) are extracted. It also is possible to specify conditions on point ids, cell ids, and on bounding box (referred to as \char`\"{}\-Extent\char`\"{}) to control the extraction process.

This filter also may be used to convert any type of data to polygonal type. The conversion process may be less than satisfactory for some 3\-D datasets. For example, this filter will extract the outer surface of a volume or structured grid dataset. (For structured data you may want to use vtk\-Image\-Data\-Geometry\-Filter, vtk\-Structured\-Grid\-Geometry\-Filter, vtk\-Extract\-Unstructured\-Grid, vtk\-Rectilinear\-Grid\-Geometry\-Filter, or vtk\-Extract\-V\-O\-I.)

To create an instance of class vtk\-Geometry\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGeometryFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Geometry\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Geometry\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Geometry\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Geometry\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Point\-Clipping (int )} -\/ Turn on/off selection of geometry by point id.  
\item {\ttfamily int = obj.\-Get\-Point\-Clipping ()} -\/ Turn on/off selection of geometry by point id.  
\item {\ttfamily obj.\-Point\-Clipping\-On ()} -\/ Turn on/off selection of geometry by point id.  
\item {\ttfamily obj.\-Point\-Clipping\-Off ()} -\/ Turn on/off selection of geometry by point id.  
\item {\ttfamily obj.\-Set\-Cell\-Clipping (int )} -\/ Turn on/off selection of geometry by cell id.  
\item {\ttfamily int = obj.\-Get\-Cell\-Clipping ()} -\/ Turn on/off selection of geometry by cell id.  
\item {\ttfamily obj.\-Cell\-Clipping\-On ()} -\/ Turn on/off selection of geometry by cell id.  
\item {\ttfamily obj.\-Cell\-Clipping\-Off ()} -\/ Turn on/off selection of geometry by cell id.  
\item {\ttfamily obj.\-Set\-Extent\-Clipping (int )} -\/ Turn on/off selection of geometry via bounding box.  
\item {\ttfamily int = obj.\-Get\-Extent\-Clipping ()} -\/ Turn on/off selection of geometry via bounding box.  
\item {\ttfamily obj.\-Extent\-Clipping\-On ()} -\/ Turn on/off selection of geometry via bounding box.  
\item {\ttfamily obj.\-Extent\-Clipping\-Off ()} -\/ Turn on/off selection of geometry via bounding box.  
\item {\ttfamily obj.\-Set\-Point\-Minimum (vtk\-Id\-Type )} -\/ Specify the minimum point id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Point\-Minimum\-Min\-Value ()} -\/ Specify the minimum point id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Point\-Minimum\-Max\-Value ()} -\/ Specify the minimum point id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Point\-Minimum ()} -\/ Specify the minimum point id for point id selection.  
\item {\ttfamily obj.\-Set\-Point\-Maximum (vtk\-Id\-Type )} -\/ Specify the maximum point id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Point\-Maximum\-Min\-Value ()} -\/ Specify the maximum point id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Point\-Maximum\-Max\-Value ()} -\/ Specify the maximum point id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Point\-Maximum ()} -\/ Specify the maximum point id for point id selection.  
\item {\ttfamily obj.\-Set\-Cell\-Minimum (vtk\-Id\-Type )} -\/ Specify the minimum cell id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Cell\-Minimum\-Min\-Value ()} -\/ Specify the minimum cell id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Cell\-Minimum\-Max\-Value ()} -\/ Specify the minimum cell id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Cell\-Minimum ()} -\/ Specify the minimum cell id for point id selection.  
\item {\ttfamily obj.\-Set\-Cell\-Maximum (vtk\-Id\-Type )} -\/ Specify the maximum cell id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Cell\-Maximum\-Min\-Value ()} -\/ Specify the maximum cell id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Cell\-Maximum\-Max\-Value ()} -\/ Specify the maximum cell id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Cell\-Maximum ()} -\/ Specify the maximum cell id for point id selection.  
\item {\ttfamily obj.\-Set\-Extent (double x\-Min, double x\-Max, double y\-Min, double y\-Max, double z\-Min, double z\-Max)} -\/ Specify a (xmin,xmax, ymin,ymax, zmin,zmax) bounding box to clip data.  
\item {\ttfamily obj.\-Set\-Extent (double extent\mbox{[}6\mbox{]})} -\/ Set / get a (xmin,xmax, ymin,ymax, zmin,zmax) bounding box to clip data.  
\item {\ttfamily double = obj.\-Get\-Extent ()} -\/ Set / get a (xmin,xmax, ymin,ymax, zmin,zmax) bounding box to clip data.  
\item {\ttfamily obj.\-Set\-Merging (int )} -\/ Turn on/off merging of coincident points. Note that is merging is on, points with different point attributes (e.\-g., normals) are merged, which may cause rendering artifacts.  
\item {\ttfamily int = obj.\-Get\-Merging ()} -\/ Turn on/off merging of coincident points. Note that is merging is on, points with different point attributes (e.\-g., normals) are merged, which may cause rendering artifacts.  
\item {\ttfamily obj.\-Merging\-On ()} -\/ Turn on/off merging of coincident points. Note that is merging is on, points with different point attributes (e.\-g., normals) are merged, which may cause rendering artifacts.  
\item {\ttfamily obj.\-Merging\-Off ()} -\/ Turn on/off merging of coincident points. Note that is merging is on, points with different point attributes (e.\-g., normals) are merged, which may cause rendering artifacts.  
\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 M\-Time also considering the locator.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkglyph2d}{}\section{vtk\-Glyph2\-D}\label{vtkgraphics_vtkglyph2d}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This subclass of vtk\-Glyph3\-D is a specialization to 2\-D. Transformations (i.\-e., translation, scaling, and rotation) are constrained to the plane. For example, rotations due to a vector are computed from the x-\/y coordinates of the vector only, and are assumed to occur around the z-\/axis. (See vtk\-Glyph3\-D for documentation on the interface to this class.)

To create an instance of class vtk\-Glyph2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGlyph2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Glyph2\-D has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Glyph2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Glyph2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Glyph2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkglyph3d}{}\section{vtk\-Glyph3\-D}\label{vtkgraphics_vtkglyph3d}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Glyph3\-D is a filter that copies a geometric representation (called a glyph) to every point in the input dataset. The glyph is defined with polygonal data from a source filter input. The glyph may be oriented along the input vectors or normals, and it may be scaled according to scalar data or vector magnitude. More than one glyph may be used by creating a table of source objects, each defining a different glyph. If a table of glyphs is defined, then the table can be indexed into by using either scalar value or vector magnitude.

To use this object you'll have to provide an input dataset and a source to define the glyph. Then decide whether you want to scale the glyph and how to scale the glyph (using scalar value or vector magnitude). Next decide whether you want to orient the glyph, and whether to use the vector data or normal data to orient it. Finally, decide whether to use a table of glyphs, or just a single glyph. If you use a table of glyphs, you'll have to decide whether to index into it with scalar value or with vector magnitude.

To create an instance of class vtk\-Glyph3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGlyph3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Glyph3\-D has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Glyph3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Glyph3\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Glyph3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Source (vtk\-Poly\-Data pd)} -\/ Set the source to use for he glyph. Old style. See Set\-Source\-Connection.  
\item {\ttfamily obj.\-Set\-Source (int id, vtk\-Poly\-Data pd)} -\/ Specify a source object at a specified table location. Old style. See Set\-Source\-Connection.  
\item {\ttfamily obj.\-Set\-Source\-Connection (int id, vtk\-Algorithm\-Output alg\-Output)} -\/ Specify a source object at a specified table location. New style. Source connection is stored in port 1. This method is equivalent to Set\-Input\-Connection(1, id, output\-Port).  
\item {\ttfamily obj.\-Set\-Source\-Connection (vtk\-Algorithm\-Output alg\-Output)} -\/ Get a pointer to a source object at a specified table location.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Source (int id)} -\/ Get a pointer to a source object at a specified table location.  
\item {\ttfamily obj.\-Set\-Scaling (int )} -\/ Turn on/off scaling of source geometry.  
\item {\ttfamily obj.\-Scaling\-On ()} -\/ Turn on/off scaling of source geometry.  
\item {\ttfamily obj.\-Scaling\-Off ()} -\/ Turn on/off scaling of source geometry.  
\item {\ttfamily int = obj.\-Get\-Scaling ()} -\/ Turn on/off scaling of source geometry.  
\item {\ttfamily obj.\-Set\-Scale\-Mode (int )} -\/ Either scale by scalar or by vector/normal magnitude.  
\item {\ttfamily int = obj.\-Get\-Scale\-Mode ()} -\/ Either scale by scalar or by vector/normal magnitude.  
\item {\ttfamily obj.\-Set\-Scale\-Mode\-To\-Scale\-By\-Scalar ()} -\/ Either scale by scalar or by vector/normal magnitude.  
\item {\ttfamily obj.\-Set\-Scale\-Mode\-To\-Scale\-By\-Vector ()} -\/ Either scale by scalar or by vector/normal magnitude.  
\item {\ttfamily obj.\-Set\-Scale\-Mode\-To\-Scale\-By\-Vector\-Components ()} -\/ Either scale by scalar or by vector/normal magnitude.  
\item {\ttfamily obj.\-Set\-Scale\-Mode\-To\-Data\-Scaling\-Off ()} -\/ Either scale by scalar or by vector/normal magnitude.  
\item {\ttfamily string = obj.\-Get\-Scale\-Mode\-As\-String ()} -\/ Either scale by scalar or by vector/normal magnitude.  
\item {\ttfamily obj.\-Set\-Color\-Mode (int )} -\/ Either color by scale, scalar or by vector/normal magnitude.  
\item {\ttfamily int = obj.\-Get\-Color\-Mode ()} -\/ Either color by scale, scalar or by vector/normal magnitude.  
\item {\ttfamily obj.\-Set\-Color\-Mode\-To\-Color\-By\-Scale ()} -\/ Either color by scale, scalar or by vector/normal magnitude.  
\item {\ttfamily obj.\-Set\-Color\-Mode\-To\-Color\-By\-Scalar ()} -\/ Either color by scale, scalar or by vector/normal magnitude.  
\item {\ttfamily obj.\-Set\-Color\-Mode\-To\-Color\-By\-Vector ()} -\/ Either color by scale, scalar or by vector/normal magnitude.  
\item {\ttfamily string = obj.\-Get\-Color\-Mode\-As\-String ()} -\/ Either color by scale, scalar or by vector/normal magnitude.  
\item {\ttfamily obj.\-Set\-Scale\-Factor (double )} -\/ Specify scale factor to scale object by.  
\item {\ttfamily double = obj.\-Get\-Scale\-Factor ()} -\/ Specify scale factor to scale object by.  
\item {\ttfamily obj.\-Set\-Range (double , double )} -\/ Specify range to map scalar values into.  
\item {\ttfamily obj.\-Set\-Range (double a\mbox{[}2\mbox{]})} -\/ Specify range to map scalar values into.  
\item {\ttfamily double = obj. Get\-Range ()} -\/ Specify range to map scalar values into.  
\item {\ttfamily obj.\-Set\-Orient (int )} -\/ Turn on/off orienting of input geometry along vector/normal.  
\item {\ttfamily obj.\-Orient\-On ()} -\/ Turn on/off orienting of input geometry along vector/normal.  
\item {\ttfamily obj.\-Orient\-Off ()} -\/ Turn on/off orienting of input geometry along vector/normal.  
\item {\ttfamily int = obj.\-Get\-Orient ()} -\/ Turn on/off orienting of input geometry along vector/normal.  
\item {\ttfamily obj.\-Set\-Clamping (int )} -\/ Turn on/off clamping of \char`\"{}scalar\char`\"{} values to range. (Scalar value may be vector magnitude if Scale\-By\-Vector() is enabled.)  
\item {\ttfamily obj.\-Clamping\-On ()} -\/ Turn on/off clamping of \char`\"{}scalar\char`\"{} values to range. (Scalar value may be vector magnitude if Scale\-By\-Vector() is enabled.)  
\item {\ttfamily obj.\-Clamping\-Off ()} -\/ Turn on/off clamping of \char`\"{}scalar\char`\"{} values to range. (Scalar value may be vector magnitude if Scale\-By\-Vector() is enabled.)  
\item {\ttfamily int = obj.\-Get\-Clamping ()} -\/ Turn on/off clamping of \char`\"{}scalar\char`\"{} values to range. (Scalar value may be vector magnitude if Scale\-By\-Vector() is enabled.)  
\item {\ttfamily obj.\-Set\-Vector\-Mode (int )} -\/ Specify whether to use vector or normal to perform vector operations.  
\item {\ttfamily int = obj.\-Get\-Vector\-Mode ()} -\/ Specify whether to use vector or normal to perform vector operations.  
\item {\ttfamily obj.\-Set\-Vector\-Mode\-To\-Use\-Vector ()} -\/ Specify whether to use vector or normal to perform vector operations.  
\item {\ttfamily obj.\-Set\-Vector\-Mode\-To\-Use\-Normal ()} -\/ Specify whether to use vector or normal to perform vector operations.  
\item {\ttfamily obj.\-Set\-Vector\-Mode\-To\-Vector\-Rotation\-Off ()} -\/ Specify whether to use vector or normal to perform vector operations.  
\item {\ttfamily string = obj.\-Get\-Vector\-Mode\-As\-String ()} -\/ Specify whether to use vector or normal to perform vector operations.  
\item {\ttfamily obj.\-Set\-Index\-Mode (int )} -\/ Index into table of sources by scalar, by vector/normal magnitude, or no indexing. If indexing is turned off, then the first source glyph in the table of glyphs is used. Note that indexing mode will only use the Input\-Scalars\-Selection array and not the Input\-Color\-Scalars\-Selection as the scalar source if an array is specified.  
\item {\ttfamily int = obj.\-Get\-Index\-Mode ()} -\/ Index into table of sources by scalar, by vector/normal magnitude, or no indexing. If indexing is turned off, then the first source glyph in the table of glyphs is used. Note that indexing mode will only use the Input\-Scalars\-Selection array and not the Input\-Color\-Scalars\-Selection as the scalar source if an array is specified.  
\item {\ttfamily obj.\-Set\-Index\-Mode\-To\-Scalar ()} -\/ Index into table of sources by scalar, by vector/normal magnitude, or no indexing. If indexing is turned off, then the first source glyph in the table of glyphs is used. Note that indexing mode will only use the Input\-Scalars\-Selection array and not the Input\-Color\-Scalars\-Selection as the scalar source if an array is specified.  
\item {\ttfamily obj.\-Set\-Index\-Mode\-To\-Vector ()} -\/ Index into table of sources by scalar, by vector/normal magnitude, or no indexing. If indexing is turned off, then the first source glyph in the table of glyphs is used. Note that indexing mode will only use the Input\-Scalars\-Selection array and not the Input\-Color\-Scalars\-Selection as the scalar source if an array is specified.  
\item {\ttfamily obj.\-Set\-Index\-Mode\-To\-Off ()} -\/ Index into table of sources by scalar, by vector/normal magnitude, or no indexing. If indexing is turned off, then the first source glyph in the table of glyphs is used. Note that indexing mode will only use the Input\-Scalars\-Selection array and not the Input\-Color\-Scalars\-Selection as the scalar source if an array is specified.  
\item {\ttfamily string = obj.\-Get\-Index\-Mode\-As\-String ()} -\/ Index into table of sources by scalar, by vector/normal magnitude, or no indexing. If indexing is turned off, then the first source glyph in the table of glyphs is used. Note that indexing mode will only use the Input\-Scalars\-Selection array and not the Input\-Color\-Scalars\-Selection as the scalar source if an array is specified.  
\item {\ttfamily obj.\-Set\-Generate\-Point\-Ids (int )} -\/ Enable/disable the generation of point ids as part of the output. The point ids are the id of the input generating point. The point ids are stored in the output point field data and named \char`\"{}\-Input\-Point\-Ids\char`\"{}. Point generation is useful for debugging and pick operations.  
\item {\ttfamily int = obj.\-Get\-Generate\-Point\-Ids ()} -\/ Enable/disable the generation of point ids as part of the output. The point ids are the id of the input generating point. The point ids are stored in the output point field data and named \char`\"{}\-Input\-Point\-Ids\char`\"{}. Point generation is useful for debugging and pick operations.  
\item {\ttfamily obj.\-Generate\-Point\-Ids\-On ()} -\/ Enable/disable the generation of point ids as part of the output. The point ids are the id of the input generating point. The point ids are stored in the output point field data and named \char`\"{}\-Input\-Point\-Ids\char`\"{}. Point generation is useful for debugging and pick operations.  
\item {\ttfamily obj.\-Generate\-Point\-Ids\-Off ()} -\/ Enable/disable the generation of point ids as part of the output. The point ids are the id of the input generating point. The point ids are stored in the output point field data and named \char`\"{}\-Input\-Point\-Ids\char`\"{}. Point generation is useful for debugging and pick operations.  
\item {\ttfamily obj.\-Set\-Point\-Ids\-Name (string )} -\/ Set/\-Get the name of the Point\-Ids array if generated. By default the Ids are named \char`\"{}\-Input\-Point\-Ids\char`\"{}, but this can be changed with this function.  
\item {\ttfamily string = obj.\-Get\-Point\-Ids\-Name ()} -\/ Set/\-Get the name of the Point\-Ids array if generated. By default the Ids are named \char`\"{}\-Input\-Point\-Ids\char`\"{}, but this can be changed with this function.  
\item {\ttfamily obj.\-Set\-Fill\-Cell\-Data (int )} -\/ Enable/disable the generation of cell data as part of the output. The cell data at each cell will match the point data of the input at the glyphed point.  
\item {\ttfamily int = obj.\-Get\-Fill\-Cell\-Data ()} -\/ Enable/disable the generation of cell data as part of the output. The cell data at each cell will match the point data of the input at the glyphed point.  
\item {\ttfamily obj.\-Fill\-Cell\-Data\-On ()} -\/ Enable/disable the generation of cell data as part of the output. The cell data at each cell will match the point data of the input at the glyphed point.  
\item {\ttfamily obj.\-Fill\-Cell\-Data\-Off ()} -\/ Enable/disable the generation of cell data as part of the output. The cell data at each cell will match the point data of the input at the glyphed point.  
\item {\ttfamily int = obj.\-Is\-Point\-Visible (vtk\-Data\-Set , vtk\-Id\-Type )} -\/ This can be overwritten by subclass to return 0 when a point is blanked. Default implementation is to always return 1;  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkglyphsource2d}{}\section{vtk\-Glyph\-Source2\-D}\label{vtkgraphics_vtkglyphsource2d}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Glyph\-Source2\-D can generate a family of 2\-D glyphs each of which lies in the x-\/y plane (i.\-e., the z-\/coordinate is zero). The class is a helper class to be used with vtk\-Glyph2\-D and vtk\-X\-Y\-Plot\-Actor.

To use this class, specify the glyph type to use and its attributes. Attributes include its position (i.\-e., center point), scale, color, and whether the symbol is filled or not (a polygon or closed line sequence). You can also put a short line through the glyph running from -\/x to +x (the glyph looks like it's on a line), or a cross.

To create an instance of class vtk\-Glyph\-Source2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGlyphSource2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Glyph\-Source2\-D has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Glyph\-Source2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Glyph\-Source2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Glyph\-Source2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Center (double , double , double )} -\/ Set the center of the glyph. By default the center is (0,0,0).  
\item {\ttfamily obj.\-Set\-Center (double a\mbox{[}3\mbox{]})} -\/ Set the center of the glyph. By default the center is (0,0,0).  
\item {\ttfamily double = obj. Get\-Center ()} -\/ Set the center of the glyph. By default the center is (0,0,0).  
\item {\ttfamily obj.\-Set\-Scale (double )} -\/ Set the scale of the glyph. Note that the glyphs are designed to fit in the (1,1) rectangle.  
\item {\ttfamily double = obj.\-Get\-Scale\-Min\-Value ()} -\/ Set the scale of the glyph. Note that the glyphs are designed to fit in the (1,1) rectangle.  
\item {\ttfamily double = obj.\-Get\-Scale\-Max\-Value ()} -\/ Set the scale of the glyph. Note that the glyphs are designed to fit in the (1,1) rectangle.  
\item {\ttfamily double = obj.\-Get\-Scale ()} -\/ Set the scale of the glyph. Note that the glyphs are designed to fit in the (1,1) rectangle.  
\item {\ttfamily obj.\-Set\-Scale2 (double )} -\/ Set the scale of optional portions of the glyph (e.\-g., the dash and cross is Dash\-On() and Cross\-On()).  
\item {\ttfamily double = obj.\-Get\-Scale2\-Min\-Value ()} -\/ Set the scale of optional portions of the glyph (e.\-g., the dash and cross is Dash\-On() and Cross\-On()).  
\item {\ttfamily double = obj.\-Get\-Scale2\-Max\-Value ()} -\/ Set the scale of optional portions of the glyph (e.\-g., the dash and cross is Dash\-On() and Cross\-On()).  
\item {\ttfamily double = obj.\-Get\-Scale2 ()} -\/ Set the scale of optional portions of the glyph (e.\-g., the dash and cross is Dash\-On() and Cross\-On()).  
\item {\ttfamily obj.\-Set\-Color (double , double , double )} -\/ Set the color of the glyph. The default color is white.  
\item {\ttfamily obj.\-Set\-Color (double a\mbox{[}3\mbox{]})} -\/ Set the color of the glyph. The default color is white.  
\item {\ttfamily double = obj. Get\-Color ()} -\/ Set the color of the glyph. The default color is white.  
\item {\ttfamily obj.\-Set\-Filled (int )} -\/ Specify whether the glyph is filled (a polygon) or not (a closed polygon defined by line segments). This only applies to 2\-D closed glyphs.  
\item {\ttfamily int = obj.\-Get\-Filled ()} -\/ Specify whether the glyph is filled (a polygon) or not (a closed polygon defined by line segments). This only applies to 2\-D closed glyphs.  
\item {\ttfamily obj.\-Filled\-On ()} -\/ Specify whether the glyph is filled (a polygon) or not (a closed polygon defined by line segments). This only applies to 2\-D closed glyphs.  
\item {\ttfamily obj.\-Filled\-Off ()} -\/ Specify whether the glyph is filled (a polygon) or not (a closed polygon defined by line segments). This only applies to 2\-D closed glyphs.  
\item {\ttfamily obj.\-Set\-Dash (int )} -\/ Specify whether a short line segment is drawn through the glyph. (This is in addition to the glyph. If the glyph type is set to \char`\"{}\-Dash\char`\"{} there is no need to enable this flag.)  
\item {\ttfamily int = obj.\-Get\-Dash ()} -\/ Specify whether a short line segment is drawn through the glyph. (This is in addition to the glyph. If the glyph type is set to \char`\"{}\-Dash\char`\"{} there is no need to enable this flag.)  
\item {\ttfamily obj.\-Dash\-On ()} -\/ Specify whether a short line segment is drawn through the glyph. (This is in addition to the glyph. If the glyph type is set to \char`\"{}\-Dash\char`\"{} there is no need to enable this flag.)  
\item {\ttfamily obj.\-Dash\-Off ()} -\/ Specify whether a short line segment is drawn through the glyph. (This is in addition to the glyph. If the glyph type is set to \char`\"{}\-Dash\char`\"{} there is no need to enable this flag.)  
\item {\ttfamily obj.\-Set\-Cross (int )} -\/ Specify whether a cross is drawn as part of the glyph. (This is in addition to the glyph. If the glyph type is set to \char`\"{}\-Cross\char`\"{} there is no need to enable this flag.)  
\item {\ttfamily int = obj.\-Get\-Cross ()} -\/ Specify whether a cross is drawn as part of the glyph. (This is in addition to the glyph. If the glyph type is set to \char`\"{}\-Cross\char`\"{} there is no need to enable this flag.)  
\item {\ttfamily obj.\-Cross\-On ()} -\/ Specify whether a cross is drawn as part of the glyph. (This is in addition to the glyph. If the glyph type is set to \char`\"{}\-Cross\char`\"{} there is no need to enable this flag.)  
\item {\ttfamily obj.\-Cross\-Off ()} -\/ Specify whether a cross is drawn as part of the glyph. (This is in addition to the glyph. If the glyph type is set to \char`\"{}\-Cross\char`\"{} there is no need to enable this flag.)  
\item {\ttfamily obj.\-Set\-Rotation\-Angle (double )} -\/ Specify an angle (in degrees) to rotate the glyph around the z-\/axis. Using this ivar, it is possible to generate rotated glyphs (e.\-g., crosses, arrows, etc.)  
\item {\ttfamily double = obj.\-Get\-Rotation\-Angle ()} -\/ Specify an angle (in degrees) to rotate the glyph around the z-\/axis. Using this ivar, it is possible to generate rotated glyphs (e.\-g., crosses, arrows, etc.)  
\item {\ttfamily obj.\-Set\-Glyph\-Type (int )} -\/ Specify the type of glyph to generate.  
\item {\ttfamily int = obj.\-Get\-Glyph\-Type\-Min\-Value ()} -\/ Specify the type of glyph to generate.  
\item {\ttfamily int = obj.\-Get\-Glyph\-Type\-Max\-Value ()} -\/ Specify the type of glyph to generate.  
\item {\ttfamily int = obj.\-Get\-Glyph\-Type ()} -\/ Specify the type of glyph to generate.  
\item {\ttfamily obj.\-Set\-Glyph\-Type\-To\-None ()} -\/ Specify the type of glyph to generate.  
\item {\ttfamily obj.\-Set\-Glyph\-Type\-To\-Vertex ()} -\/ Specify the type of glyph to generate.  
\item {\ttfamily obj.\-Set\-Glyph\-Type\-To\-Dash ()} -\/ Specify the type of glyph to generate.  
\item {\ttfamily obj.\-Set\-Glyph\-Type\-To\-Cross ()} -\/ Specify the type of glyph to generate.  
\item {\ttfamily obj.\-Set\-Glyph\-Type\-To\-Thick\-Cross ()} -\/ Specify the type of glyph to generate.  
\item {\ttfamily obj.\-Set\-Glyph\-Type\-To\-Triangle ()} -\/ Specify the type of glyph to generate.  
\item {\ttfamily obj.\-Set\-Glyph\-Type\-To\-Square ()} -\/ Specify the type of glyph to generate.  
\item {\ttfamily obj.\-Set\-Glyph\-Type\-To\-Circle ()} -\/ Specify the type of glyph to generate.  
\item {\ttfamily obj.\-Set\-Glyph\-Type\-To\-Diamond ()} -\/ Specify the type of glyph to generate.  
\item {\ttfamily obj.\-Set\-Glyph\-Type\-To\-Arrow ()} -\/ Specify the type of glyph to generate.  
\item {\ttfamily obj.\-Set\-Glyph\-Type\-To\-Thick\-Arrow ()} -\/ Specify the type of glyph to generate.  
\item {\ttfamily obj.\-Set\-Glyph\-Type\-To\-Hooked\-Arrow ()} -\/ Specify the type of glyph to generate.  
\item {\ttfamily obj.\-Set\-Glyph\-Type\-To\-Edge\-Arrow ()}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkgradientfilter}{}\section{vtk\-Gradient\-Filter}\label{vtkgraphics_vtkgradientfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Estimates the gradient of a field in a data set. The gradient calculation is dependent on the input dataset type. The created gradient array is of the same type as the array it is calculated from (e.\-g. point data or cell data) as well as data type (e.\-g. float, double). At the boundary the gradient is not central differencing. The output array has 3$\ast$number of components of the input data array. The ordering for the output tuple will be \{du/dx, du/dy, du/dz, dv/dx, dv/dy, dv/dz, dw/dx, dw/dy, dw/dz\} for an input array \{u, v, w\}.

To create an instance of class vtk\-Gradient\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGradientFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Gradient\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Gradient\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Gradient\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Gradient\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Input\-Scalars (int field\-Association, string name)} -\/ These are basically a convenience method that calls Set\-Input\-Array\-To\-Process to set the array used as the input scalars. The field\-Association comes from the vtk\-Data\-Object\-::\-Field\-Assocations enum. The field\-Attribute\-Type comes from the vtk\-Data\-Set\-Attributes\-::\-Attribute\-Types enum.  
\item {\ttfamily obj.\-Set\-Input\-Scalars (int field\-Association, int field\-Attribute\-Type)} -\/ These are basically a convenience method that calls Set\-Input\-Array\-To\-Process to set the array used as the input scalars. The field\-Association comes from the vtk\-Data\-Object\-::\-Field\-Assocations enum. The field\-Attribute\-Type comes from the vtk\-Data\-Set\-Attributes\-::\-Attribute\-Types enum.  
\item {\ttfamily string = obj.\-Get\-Result\-Array\-Name ()} -\/ Get/\-Set the name of the resulting array to create. If N\-U\-L\-L (the default) then the output array will be named \char`\"{}\-Gradients\char`\"{}.  
\item {\ttfamily obj.\-Set\-Result\-Array\-Name (string )} -\/ Get/\-Set the name of the resulting array to create. If N\-U\-L\-L (the default) then the output array will be named \char`\"{}\-Gradients\char`\"{}.  
\item {\ttfamily int = obj.\-Get\-Faster\-Approximation ()} -\/ When this flag is on (default is off), the gradient filter will provide a less accurate (but close) algorithm that performs fewer derivative calculations (and is therefore faster). The error contains some smoothing of the output data and some possible errors on the boundary. This parameter has no effect when performing the gradient of cell data. This only applies if the input grid is a vtk\-Unstructured\-Grid or a vtk\-Poly\-Data.  
\item {\ttfamily obj.\-Set\-Faster\-Approximation (int )} -\/ When this flag is on (default is off), the gradient filter will provide a less accurate (but close) algorithm that performs fewer derivative calculations (and is therefore faster). The error contains some smoothing of the output data and some possible errors on the boundary. This parameter has no effect when performing the gradient of cell data. This only applies if the input grid is a vtk\-Unstructured\-Grid or a vtk\-Poly\-Data.  
\item {\ttfamily obj.\-Faster\-Approximation\-On ()} -\/ When this flag is on (default is off), the gradient filter will provide a less accurate (but close) algorithm that performs fewer derivative calculations (and is therefore faster). The error contains some smoothing of the output data and some possible errors on the boundary. This parameter has no effect when performing the gradient of cell data. This only applies if the input grid is a vtk\-Unstructured\-Grid or a vtk\-Poly\-Data.  
\item {\ttfamily obj.\-Faster\-Approximation\-Off ()} -\/ When this flag is on (default is off), the gradient filter will provide a less accurate (but close) algorithm that performs fewer derivative calculations (and is therefore faster). The error contains some smoothing of the output data and some possible errors on the boundary. This parameter has no effect when performing the gradient of cell data. This only applies if the input grid is a vtk\-Unstructured\-Grid or a vtk\-Poly\-Data.  
\item {\ttfamily obj.\-Set\-Compute\-Vorticity (int )} -\/ Set the resultant array to be vorticity/curl of the input array. The input array must have 3 components.  
\item {\ttfamily int = obj.\-Get\-Compute\-Vorticity ()} -\/ Set the resultant array to be vorticity/curl of the input array. The input array must have 3 components.  
\item {\ttfamily obj.\-Compute\-Vorticity\-On ()} -\/ Set the resultant array to be vorticity/curl of the input array. The input array must have 3 components.  
\item {\ttfamily obj.\-Compute\-Vorticity\-Off ()} -\/ Set the resultant array to be vorticity/curl of the input array. The input array must have 3 components.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkgraphgeodesicpath}{}\section{vtk\-Graph\-Geodesic\-Path}\label{vtkgraphics_vtkgraphgeodesicpath}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Serves as a base class for algorithms that trace a geodesic on a polygonal dataset treating it as a graph. ie points connecting the vertices of the graph

To create an instance of class vtk\-Graph\-Geodesic\-Path, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGraphGeodesicPath
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Graph\-Geodesic\-Path has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Graph\-Geodesic\-Path class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methids for printing and determining type information.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methids for printing and determining type information.  
\item {\ttfamily vtk\-Graph\-Geodesic\-Path = obj.\-New\-Instance ()} -\/ Standard methids for printing and determining type information.  
\item {\ttfamily vtk\-Graph\-Geodesic\-Path = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methids for printing and determining type information.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Start\-Vertex ()} -\/ The vertex at the start of the shortest path  
\item {\ttfamily obj.\-Set\-Start\-Vertex (vtk\-Id\-Type )} -\/ The vertex at the start of the shortest path  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-End\-Vertex ()} -\/ The vertex at the end of the shortest path  
\item {\ttfamily obj.\-Set\-End\-Vertex (vtk\-Id\-Type )} -\/ The vertex at the end of the shortest path  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkgraphlayoutfilter}{}\section{vtk\-Graph\-Layout\-Filter}\label{vtkgraphics_vtkgraphlayoutfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Graph\-Layout\-Filter will reposition a network of nodes, connected by lines or polylines, into a more pleasing arrangement. The class implements a simple force-\/directed placement algorithm (Fruchterman \& Reingold \char`\"{}\-Graph Drawing by Force-\/directed Placement\char`\"{} Software-\/\-Practice and Experience 21(11) 1991).

The input to the filter is a vtk\-Poly\-Data representing the undirected graphs. A graph is represented by a set of polylines and/or lines. The output is also a vtk\-Poly\-Data, where the point positions have been modified. To use the filter, specify whether you wish the layout to occur in 2\-D or 3\-D; the bounds in which the graph should lie (note that you can just use automatic bounds computation); and modify the cool down rate (controls the final process of simulated annealing).

To create an instance of class vtk\-Graph\-Layout\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGraphLayoutFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Graph\-Layout\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Layout\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Graph\-Layout\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Graph\-Layout\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Graph\-Bounds (double , double , double , double , double , double )} -\/ Set / get the region in space in which to place the final graph. The Graph\-Bounds only affects the results if Automatic\-Bounds\-Computation is off.  
\item {\ttfamily obj.\-Set\-Graph\-Bounds (double a\mbox{[}6\mbox{]})} -\/ Set / get the region in space in which to place the final graph. The Graph\-Bounds only affects the results if Automatic\-Bounds\-Computation is off.  
\item {\ttfamily double = obj. Get\-Graph\-Bounds ()} -\/ Set / get the region in space in which to place the final graph. The Graph\-Bounds only affects the results if Automatic\-Bounds\-Computation is off.  
\item {\ttfamily obj.\-Set\-Automatic\-Bounds\-Computation (int )} -\/ Turn on/off automatic graph bounds calculation. If this boolean is off, then the manually specified Graph\-Bounds is used. If on, then the input's bounds us used as the graph bounds.  
\item {\ttfamily int = obj.\-Get\-Automatic\-Bounds\-Computation ()} -\/ Turn on/off automatic graph bounds calculation. If this boolean is off, then the manually specified Graph\-Bounds is used. If on, then the input's bounds us used as the graph bounds.  
\item {\ttfamily obj.\-Automatic\-Bounds\-Computation\-On ()} -\/ Turn on/off automatic graph bounds calculation. If this boolean is off, then the manually specified Graph\-Bounds is used. If on, then the input's bounds us used as the graph bounds.  
\item {\ttfamily obj.\-Automatic\-Bounds\-Computation\-Off ()} -\/ Turn on/off automatic graph bounds calculation. If this boolean is off, then the manually specified Graph\-Bounds is used. If on, then the input's bounds us used as the graph bounds.  
\item {\ttfamily obj.\-Set\-Max\-Number\-Of\-Iterations (int )} -\/ Set/\-Get the maximum number of iterations to be used. The higher this number, the more iterations through the algorithm is possible, and thus, the more the graph gets modified.  
\item {\ttfamily int = obj.\-Get\-Max\-Number\-Of\-Iterations\-Min\-Value ()} -\/ Set/\-Get the maximum number of iterations to be used. The higher this number, the more iterations through the algorithm is possible, and thus, the more the graph gets modified.  
\item {\ttfamily int = obj.\-Get\-Max\-Number\-Of\-Iterations\-Max\-Value ()} -\/ Set/\-Get the maximum number of iterations to be used. The higher this number, the more iterations through the algorithm is possible, and thus, the more the graph gets modified.  
\item {\ttfamily int = obj.\-Get\-Max\-Number\-Of\-Iterations ()} -\/ Set/\-Get the maximum number of iterations to be used. The higher this number, the more iterations through the algorithm is possible, and thus, the more the graph gets modified.  
\item {\ttfamily obj.\-Set\-Cool\-Down\-Rate (double )} -\/ Set/\-Get the Cool-\/down rate. The higher this number is, the longer it will take to \char`\"{}cool-\/down\char`\"{}, and thus, the more the graph will be modified.  
\item {\ttfamily double = obj.\-Get\-Cool\-Down\-Rate\-Min\-Value ()} -\/ Set/\-Get the Cool-\/down rate. The higher this number is, the longer it will take to \char`\"{}cool-\/down\char`\"{}, and thus, the more the graph will be modified.  
\item {\ttfamily double = obj.\-Get\-Cool\-Down\-Rate\-Max\-Value ()} -\/ Set/\-Get the Cool-\/down rate. The higher this number is, the longer it will take to \char`\"{}cool-\/down\char`\"{}, and thus, the more the graph will be modified.  
\item {\ttfamily double = obj.\-Get\-Cool\-Down\-Rate ()} -\/ Set/\-Get the Cool-\/down rate. The higher this number is, the longer it will take to \char`\"{}cool-\/down\char`\"{}, and thus, the more the graph will be modified.  
\item {\ttfamily obj.\-Set\-Three\-Dimensional\-Layout (int )}  
\item {\ttfamily int = obj.\-Get\-Three\-Dimensional\-Layout ()}  
\item {\ttfamily obj.\-Three\-Dimensional\-Layout\-On ()}  
\item {\ttfamily obj.\-Three\-Dimensional\-Layout\-Off ()}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkgraphtopoints}{}\section{vtk\-Graph\-To\-Points}\label{vtkgraphics_vtkgraphtopoints}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Converts a vtk\-Graph to a vtk\-Poly\-Data containing a set of points. This assumes that the points of the graph have already been filled (perhaps by vtk\-Graph\-Layout). The vertex data is passed along to the point data.

To create an instance of class vtk\-Graph\-To\-Points, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGraphToPoints
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Graph\-To\-Points has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Graph\-To\-Points class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Graph\-To\-Points = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Graph\-To\-Points = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkgraphtopolydata}{}\section{vtk\-Graph\-To\-Poly\-Data}\label{vtkgraphics_vtkgraphtopolydata}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Converts a vtk\-Graph to a vtk\-Poly\-Data. This assumes that the points of the graph have already been filled (perhaps by vtk\-Graph\-Layout), and coverts all the edge of the graph into lines in the polydata. The vertex data is passed along to the point data, and the edge data is passed along to the cell data.

Only the owned graph edges (i.\-e. edges with ghost level 0) are copied into the vtk\-Poly\-Data.

To create an instance of class vtk\-Graph\-To\-Poly\-Data, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGraphToPolyData
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Graph\-To\-Poly\-Data has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Graph\-To\-Poly\-Data class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Graph\-To\-Poly\-Data = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Graph\-To\-Poly\-Data = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Edge\-Glyph\-Output (bool )} -\/ Create a second output containing points and orientation vectors for drawing arrows or other glyphs on edges. This output should be set as the first input to vtk\-Glyph3\-D to place glyphs on the edges. vtk\-Glyph\-Source2\-D's V\-T\-K\-\_\-\-E\-D\-G\-E\-A\-R\-R\-O\-W\-\_\-\-G\-L\-Y\-P\-H provides a good glyph for drawing arrows. Default value is off.  
\item {\ttfamily bool = obj.\-Get\-Edge\-Glyph\-Output ()} -\/ Create a second output containing points and orientation vectors for drawing arrows or other glyphs on edges. This output should be set as the first input to vtk\-Glyph3\-D to place glyphs on the edges. vtk\-Glyph\-Source2\-D's V\-T\-K\-\_\-\-E\-D\-G\-E\-A\-R\-R\-O\-W\-\_\-\-G\-L\-Y\-P\-H provides a good glyph for drawing arrows. Default value is off.  
\item {\ttfamily obj.\-Edge\-Glyph\-Output\-On ()} -\/ Create a second output containing points and orientation vectors for drawing arrows or other glyphs on edges. This output should be set as the first input to vtk\-Glyph3\-D to place glyphs on the edges. vtk\-Glyph\-Source2\-D's V\-T\-K\-\_\-\-E\-D\-G\-E\-A\-R\-R\-O\-W\-\_\-\-G\-L\-Y\-P\-H provides a good glyph for drawing arrows. Default value is off.  
\item {\ttfamily obj.\-Edge\-Glyph\-Output\-Off ()} -\/ Create a second output containing points and orientation vectors for drawing arrows or other glyphs on edges. This output should be set as the first input to vtk\-Glyph3\-D to place glyphs on the edges. vtk\-Glyph\-Source2\-D's V\-T\-K\-\_\-\-E\-D\-G\-E\-A\-R\-R\-O\-W\-\_\-\-G\-L\-Y\-P\-H provides a good glyph for drawing arrows. Default value is off.  
\item {\ttfamily obj.\-Set\-Edge\-Glyph\-Position (double )} -\/ The position of the glyph point along the edge. 0 puts a glyph point at the source of each edge. 1 puts a glyph point at the target of each edge. An intermediate value will place the glyph point between the source and target. The default value is 1.  
\item {\ttfamily double = obj.\-Get\-Edge\-Glyph\-Position ()} -\/ The position of the glyph point along the edge. 0 puts a glyph point at the source of each edge. 1 puts a glyph point at the target of each edge. An intermediate value will place the glyph point between the source and target. The default value is 1.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkgridsynchronizedtemplates3d}{}\section{vtk\-Grid\-Synchronized\-Templates3\-D}\label{vtkgraphics_vtkgridsynchronizedtemplates3d}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Grid\-Synchronized\-Templates3\-D is a 3\-D implementation of the synchronized template algorithm.

To create an instance of class vtk\-Grid\-Synchronized\-Templates3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGridSynchronizedTemplates3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Grid\-Synchronized\-Templates3\-D has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Grid\-Synchronized\-Templates3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Grid\-Synchronized\-Templates3\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Grid\-Synchronized\-Templates3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Because we delegate to vtk\-Contour\-Values  
\item {\ttfamily obj.\-Set\-Compute\-Normals (int )} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily int = obj.\-Get\-Compute\-Normals ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Normals\-On ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Normals\-Off ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Set\-Compute\-Gradients (int )} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily int = obj.\-Get\-Compute\-Gradients ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Gradients\-On ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Gradients\-Off ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Set\-Compute\-Scalars (int )} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily int = obj.\-Get\-Compute\-Scalars ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Compute\-Scalars\-On ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Compute\-Scalars\-Off ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Set\-Value (int i, double value)} -\/ Get the ith contour value.  
\item {\ttfamily double = obj.\-Get\-Value (int i)} -\/ Get a pointer to an array of contour values. There will be Get\-Number\-Of\-Contours() values in the list.  
\item {\ttfamily obj.\-Get\-Values (double contour\-Values)} -\/ Set the number of contours to place into the list. You only really need to use this method to reduce list size. The method Set\-Value() will automatically increase list size as needed.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Contours (int number)} -\/ Get the number of contours in the list of contour values.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Contours ()} -\/ Generate num\-Contours equally spaced contour values between specified range. Contour values will include min/max range values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\mbox{[}2\mbox{]})} -\/ Generate num\-Contours equally spaced contour values between specified range. Contour values will include min/max range values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\-Start, double range\-End)} -\/ Needed by templated functions.  
\item {\ttfamily int = obj.\-Get\-Execute\-Extent ()} -\/ Needed by templated functions.  
\item {\ttfamily obj.\-Set\-Input\-Memory\-Limit (long limit)} -\/ This filter will initiate streaming so that no piece requested from the input will be larger than this value (Kilo\-Bytes).  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkhedgehog}{}\section{vtk\-Hedge\-Hog}\label{vtkgraphics_vtkhedgehog}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Hedge\-Hog creates oriented lines from the input data set. Line length is controlled by vector (or normal) magnitude times scale factor. If Vector\-Mode is Use\-Normal, normals determine the orientation of the lines. Lines are colored by scalar data, if available.

To create an instance of class vtk\-Hedge\-Hog, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHedgeHog
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Hedge\-Hog has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Hedge\-Hog class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Hedge\-Hog = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Hedge\-Hog = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Scale\-Factor (double )} -\/ Set scale factor to control size of oriented lines.  
\item {\ttfamily double = obj.\-Get\-Scale\-Factor ()} -\/ Set scale factor to control size of oriented lines.  
\item {\ttfamily obj.\-Set\-Vector\-Mode (int )} -\/ Specify whether to use vector or normal to perform vector operations.  
\item {\ttfamily int = obj.\-Get\-Vector\-Mode ()} -\/ Specify whether to use vector or normal to perform vector operations.  
\item {\ttfamily obj.\-Set\-Vector\-Mode\-To\-Use\-Vector ()} -\/ Specify whether to use vector or normal to perform vector operations.  
\item {\ttfamily obj.\-Set\-Vector\-Mode\-To\-Use\-Normal ()} -\/ Specify whether to use vector or normal to perform vector operations.  
\item {\ttfamily string = obj.\-Get\-Vector\-Mode\-As\-String ()} -\/ Specify whether to use vector or normal to perform vector operations.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkhierarchicaldataextractdatasets}{}\section{vtk\-Hierarchical\-Data\-Extract\-Data\-Sets}\label{vtkgraphics_vtkhierarchicaldataextractdatasets}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Legacy class. Use vtk\-Extract\-Data\-Sets instead.

To create an instance of class vtk\-Hierarchical\-Data\-Extract\-Data\-Sets, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHierarchicalDataExtractDataSets
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Hierarchical\-Data\-Extract\-Data\-Sets has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Hierarchical\-Data\-Extract\-Data\-Sets class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Hierarchical\-Data\-Extract\-Data\-Sets = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Hierarchical\-Data\-Extract\-Data\-Sets = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkhierarchicaldataextractlevel}{}\section{vtk\-Hierarchical\-Data\-Extract\-Level}\label{vtkgraphics_vtkhierarchicaldataextractlevel}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Legacy class. Use vtk\-Extract\-Level instead.

To create an instance of class vtk\-Hierarchical\-Data\-Extract\-Level, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHierarchicalDataExtractLevel
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Hierarchical\-Data\-Extract\-Level has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Hierarchical\-Data\-Extract\-Level class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Hierarchical\-Data\-Extract\-Level = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Hierarchical\-Data\-Extract\-Level = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkhierarchicaldatalevelfilter}{}\section{vtk\-Hierarchical\-Data\-Level\-Filter}\label{vtkgraphics_vtkhierarchicaldatalevelfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Legacy class. Use vtk\-Level\-Id\-Scalars instead.

To create an instance of class vtk\-Hierarchical\-Data\-Level\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHierarchicalDataLevelFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Hierarchical\-Data\-Level\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Hierarchical\-Data\-Level\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Hierarchical\-Data\-Level\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Hierarchical\-Data\-Level\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkhierarchicaldatasetgeometryfilter}{}\section{vtk\-Hierarchical\-Data\-Set\-Geometry\-Filter}\label{vtkgraphics_vtkhierarchicaldatasetgeometryfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Legacy class. Use vtk\-Composite\-Data\-Geometry\-Filter instead.

To create an instance of class vtk\-Hierarchical\-Data\-Set\-Geometry\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHierarchicalDataSetGeometryFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Hierarchical\-Data\-Set\-Geometry\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Hierarchical\-Data\-Set\-Geometry\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Hierarchical\-Data\-Set\-Geometry\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Hierarchical\-Data\-Set\-Geometry\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkhull}{}\section{vtk\-Hull}\label{vtkgraphics_vtkhull}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Hull is a filter which will produce an n-\/sided convex hull given a set of n planes. (The convex hull bounds the input polygonal data.) The hull is generated by squeezing the planes towards the input vtk\-Poly\-Data, until the planes just touch the vtk\-Poly\-Data. Then, the resulting planes are used to generate a polyhedron (i.\-e., hull) that is represented by triangles.

The n planes can be defined in a number of ways including 1) manually specifying each plane; 2) choosing the six face planes of the input's bounding box; 3) choosing the eight vertex planes of the input's bounding box; 4) choosing the twelve edge planes of the input's bounding box; and/or 5) using a recursively subdivided octahedron. Note that when specifying planes, the plane normals should point outside of the convex region.

The output of this filter can be used in combination with vtk\-L\-O\-D\-Actor to represent a levels-\/of-\/detail in the L\-O\-D hierarchy. Another use of this class is to manually specify the planes, and then generate the polyhedron from the planes (without squeezing the planes towards the input). The method Generate\-Hull() is used to do this.

To create an instance of class vtk\-Hull, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHull
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Hull has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Hull class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Hull = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Hull = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Remove\-All\-Planes (void )} -\/ Remove all planes from the current set of planes.  
\item {\ttfamily int = obj.\-Add\-Plane (double A, double B, double C)} -\/ Add a plane to the current set of planes. It will be added at the end of the list, and an index that can later be used to set this plane's normal will be returned. The values A, B, C are from the plane equation Ax + By + Cz + D = 0. This vector does not have to have unit length (but it must have a non-\/zero length!). If a value 0 $>$ i $>$= -\/\-Number\-Of\-Planes is returned, then the plane is parallel with a previously inserted plane, and $|$-\/i-\/1$|$ is the index of the plane that was previously inserted. If a value i $<$ -\/\-Number\-Of\-Planes is returned, then the plane normal is zero length.  
\item {\ttfamily int = obj.\-Add\-Plane (double plane\mbox{[}3\mbox{]})} -\/ Add a plane to the current set of planes. It will be added at the end of the list, and an index that can later be used to set this plane's normal will be returned. The values A, B, C are from the plane equation Ax + By + Cz + D = 0. This vector does not have to have unit length (but it must have a non-\/zero length!). If a value 0 $>$ i $>$= -\/\-Number\-Of\-Planes is returned, then the plane is parallel with a previously inserted plane, and $|$-\/i-\/1$|$ is the index of the plane that was previously inserted. If a value i $<$ -\/\-Number\-Of\-Planes is returned, then the plane normal is zero length.  
\item {\ttfamily obj.\-Set\-Plane (int i, double A, double B, double C)} -\/ Set the normal values for plane i. This is a plane that was already added to the current set of planes with Add\-Plane(), and is now being modified. The values A, B, C are from the plane equation Ax + By + Cz + D = 0. This vector does not have to have unit length. Note that D is set to zero, except in the case of the method taking a vtk\-Planes$\ast$ argument, where it is set to the D value defined there.  
\item {\ttfamily obj.\-Set\-Plane (int i, double plane\mbox{[}3\mbox{]})} -\/ Set the normal values for plane i. This is a plane that was already added to the current set of planes with Add\-Plane(), and is now being modified. The values A, B, C are from the plane equation Ax + By + Cz + D = 0. This vector does not have to have unit length. Note that D is set to zero, except in the case of the method taking a vtk\-Planes$\ast$ argument, where it is set to the D value defined there.  
\item {\ttfamily int = obj.\-Add\-Plane (double A, double B, double C, double D)} -\/ Variations of Add\-Plane()/\-Set\-Plane() that allow D to be set. These methods are used when Generate\-Hull() is used.  
\item {\ttfamily int = obj.\-Add\-Plane (double plane\mbox{[}3\mbox{]}, double D)} -\/ Variations of Add\-Plane()/\-Set\-Plane() that allow D to be set. These methods are used when Generate\-Hull() is used.  
\item {\ttfamily obj.\-Set\-Plane (int i, double A, double B, double C, double D)} -\/ Variations of Add\-Plane()/\-Set\-Plane() that allow D to be set. These methods are used when Generate\-Hull() is used.  
\item {\ttfamily obj.\-Set\-Plane (int i, double plane\mbox{[}3\mbox{]}, double D)} -\/ Variations of Add\-Plane()/\-Set\-Plane() that allow D to be set. These methods are used when Generate\-Hull() is used.  
\item {\ttfamily obj.\-Set\-Planes (vtk\-Planes planes)} -\/ Set all the planes at once using a vtk\-Planes implicit function. This also sets the D value, so it can be used with Generate\-Hull().  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Planes ()} -\/ Get the number of planes in the current set of planes.  
\item {\ttfamily obj.\-Add\-Cube\-Vertex\-Planes ()} -\/ Add the 8 planes that represent the vertices of a cube -\/ the combination of the three face planes connecting to a vertex -\/ (1,1,1), (1,1,-\/1), (1,-\/1,1), (1,-\/1,1), (-\/1,1,1), (-\/1,1,-\/1), (-\/1,-\/1,1), (-\/1,-\/1-\/1).  
\item {\ttfamily obj.\-Add\-Cube\-Edge\-Planes ()} -\/ Add the 12 planes that represent the edges of a cube -\/ halfway between the two connecting face planes -\/ (1,1,0), (-\/1,-\/1,0), (-\/1,1,0), (1,-\/1,0), (0,1,1), (0,-\/1,-\/1), (0,1,-\/1), (0,-\/1,1), (1,0,1), (-\/1,0,-\/1), (1,0,-\/1), (-\/1,0,1)  
\item {\ttfamily obj.\-Add\-Cube\-Face\-Planes ()} -\/ Add the six planes that make up the faces of a cube -\/ (1,0,0), (-\/1, 0, 0), (0,1,0), (0,-\/1,0), (0,0,1), (0,0,-\/1)  
\item {\ttfamily obj.\-Add\-Recursive\-Sphere\-Planes (int level)} -\/ Add the planes that represent the normals of the vertices of a polygonal sphere formed by recursively subdividing the triangles in an octahedron. Each triangle is subdivided by connecting the midpoints of the edges thus forming 4 smaller triangles. The level indicates how many subdivisions to do with a level of 0 used to add the 6 planes from the original octahedron, level 1 will add 18 planes, and so on.  
\item {\ttfamily obj.\-Generate\-Hull (vtk\-Poly\-Data pd, double bounds)} -\/ A special method that is used to generate a polyhedron directly from a set of n planes. The planes that are supplied by the user are not squeezed towards the input data (in fact the user need not specify an input). To use this method, you must provide an instance of vtk\-Poly\-Data into which the points and cells defining the polyhedron are placed. You must also provide a bounding box where you expect the resulting polyhedron to lie. This can be a very generous fit, it's only used to create the initial polygons that are eventually clipped.  
\item {\ttfamily obj.\-Generate\-Hull (vtk\-Poly\-Data pd, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)} -\/ A special method that is used to generate a polyhedron directly from a set of n planes. The planes that are supplied by the user are not squeezed towards the input data (in fact the user need not specify an input). To use this method, you must provide an instance of vtk\-Poly\-Data into which the points and cells defining the polyhedron are placed. You must also provide a bounding box where you expect the resulting polyhedron to lie. This can be a very generous fit, it's only used to create the initial polygons that are eventually clipped.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkhyperoctreecontourfilter}{}\section{vtk\-Hyper\-Octree\-Contour\-Filter}\label{vtkgraphics_vtkhyperoctreecontourfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Contour\-Filter is a filter that takes as input any dataset and generates on output isosurfaces and/or isolines. The exact form of the output depends upon the dimensionality of the input data. Data consisting of 3\-D cells will generate isosurfaces, data consisting of 2\-D cells will generate isolines, and data with 1\-D or 0\-D cells will generate isopoints. Combinations of output type are possible if the input dimension is mixed.

To use this filter you must specify one or more contour values. You can either use the method Set\-Value() to specify each contour value, or use Generate\-Values() to generate a series of evenly spaced contours. It is also possible to accelerate the operation of this filter (at the cost of extra memory) by using a vtk\-Scalar\-Tree. A scalar tree is used to quickly locate cells that contain a contour surface. This is especially effective if multiple contours are being extracted. If you want to use a scalar tree, invoke the method Use\-Scalar\-Tree\-On().

To create an instance of class vtk\-Hyper\-Octree\-Contour\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHyperOctreeContourFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Hyper\-Octree\-Contour\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Hyper\-Octree\-Contour\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Hyper\-Octree\-Contour\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Hyper\-Octree\-Contour\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Value (int i, double value)} -\/ Get the ith contour value.  
\item {\ttfamily double = obj.\-Get\-Value (int i)} -\/ Get a pointer to an array of contour values. There will be Get\-Number\-Of\-Contours() values in the list.  
\item {\ttfamily obj.\-Get\-Values (double contour\-Values)} -\/ Set the number of contours to place into the list. You only really need to use this method to reduce list size. The method Set\-Value() will automatically increase list size as needed.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Contours (int number)} -\/ Get the number of contours in the list of contour values.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Contours ()} -\/ Generate num\-Contours equally spaced contour values between specified range. Contour values will include min/max range values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\mbox{[}2\mbox{]})} -\/ Generate num\-Contours equally spaced contour values between specified range. Contour values will include min/max range values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\-Start, double range\-End)} -\/ Modified Get\-M\-Time Because we delegate to vtk\-Contour\-Values  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Modified Get\-M\-Time Because we delegate to vtk\-Contour\-Values  
\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. The locator is used to merge coincident points.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkhyperoctreecutter}{}\section{vtk\-Hyper\-Octree\-Cutter}\label{vtkgraphics_vtkhyperoctreecutter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Hyper\-Octree\-Cutter is a filter to cut through data using any subclass of vtk\-Implicit\-Function. That is, a polygonal surface is created corresponding to the implicit function F(x,y,z) = value(s), where you can specify one or more values used to cut with.

In V\-T\-K, cutting means reducing a cell of dimension N to a cut surface of dimension N-\/1. For example, a tetrahedron when cut by a plane (i.\-e., vtk\-Plane implicit function) will generate triangles. (In comparison, clipping takes a N dimensional cell and creates N dimension primitives.)

vtk\-Hyper\-Octree\-Cutter is generally used to \char`\"{}slice-\/through\char`\"{} a dataset, generating a surface that can be visualized. It is also possible to use vtk\-Hyper\-Octree\-Cutter to do a form of volume rendering. vtk\-Hyper\-Octree\-Cutter does this by generating multiple cut surfaces (usually planes) which are ordered (and rendered) from back-\/to-\/front. The surfaces are set translucent to give a volumetric rendering effect.

Note that data can be cut using either 1) the scalar values associated with the dataset or 2) an implicit function associated with this class. By default, if an implicit function is set it is used to cut the data set, otherwise the dataset scalars are used to perform the cut.

To create an instance of class vtk\-Hyper\-Octree\-Cutter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHyperOctreeCutter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Hyper\-Octree\-Cutter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Hyper\-Octree\-Cutter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Hyper\-Octree\-Cutter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Hyper\-Octree\-Cutter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Value (int i, double value)} -\/ Get the ith contour value.  
\item {\ttfamily double = obj.\-Get\-Value (int i)} -\/ Get a pointer to an array of contour values. There will be Get\-Number\-Of\-Contours() values in the list.  
\item {\ttfamily obj.\-Get\-Values (double contour\-Values)} -\/ Set the number of contours to place into the list. You only really need to use this method to reduce list size. The method Set\-Value() will automatically increase list size as needed.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Contours (int number)} -\/ Get the number of contours in the list of contour values.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Contours ()} -\/ Generate num\-Contours equally spaced contour values between specified range. Contour values will include min/max range values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\mbox{[}2\mbox{]})} -\/ Generate num\-Contours equally spaced contour values between specified range. Contour values will include min/max range values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\-Start, double range\-End)} -\/ Override Get\-M\-Time because we delegate to vtk\-Contour\-Values and refer to vtk\-Implicit\-Function.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Override Get\-M\-Time because we delegate to vtk\-Contour\-Values and refer to vtk\-Implicit\-Function.  
\item {\ttfamily obj.\-Set\-Cut\-Function (vtk\-Implicit\-Function )}  
\item {\ttfamily vtk\-Implicit\-Function = obj.\-Get\-Cut\-Function ()}  
\item {\ttfamily obj.\-Set\-Generate\-Cut\-Scalars (int )} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data.  
\item {\ttfamily int = obj.\-Get\-Generate\-Cut\-Scalars ()} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data.  
\item {\ttfamily obj.\-Generate\-Cut\-Scalars\-On ()} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data.  
\item {\ttfamily obj.\-Generate\-Cut\-Scalars\-Off ()} -\/ If this flag is enabled, then the output scalar values will be interpolated from the implicit function values, and not the input scalar data.  
\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.\-Set\-Sort\-By (int )} -\/ Set the sorting order for the generated polydata. There are two possibilities\-: Sort by value = 0 -\/ This is the most efficient sort. For each cell, all contour values are processed. This is the default. Sort by cell = 1 -\/ For each contour value, all cells are processed. This order should be used if the extracted polygons must be rendered in a back-\/to-\/front or front-\/to-\/back order. This is very problem dependent. For most applications, the default order is fine (and faster).

Sort by cell is going to have a problem if the input has 2\-D and 3\-D cells. Cell data will be scrambled becauses with vtk\-Poly\-Data output, verts and lines have lower cell ids than triangles.  
\item {\ttfamily int = obj.\-Get\-Sort\-By\-Min\-Value ()} -\/ Set the sorting order for the generated polydata. There are two possibilities\-: Sort by value = 0 -\/ This is the most efficient sort. For each cell, all contour values are processed. This is the default. Sort by cell = 1 -\/ For each contour value, all cells are processed. This order should be used if the extracted polygons must be rendered in a back-\/to-\/front or front-\/to-\/back order. This is very problem dependent. For most applications, the default order is fine (and faster).

Sort by cell is going to have a problem if the input has 2\-D and 3\-D cells. Cell data will be scrambled becauses with vtk\-Poly\-Data output, verts and lines have lower cell ids than triangles.  
\item {\ttfamily int = obj.\-Get\-Sort\-By\-Max\-Value ()} -\/ Set the sorting order for the generated polydata. There are two possibilities\-: Sort by value = 0 -\/ This is the most efficient sort. For each cell, all contour values are processed. This is the default. Sort by cell = 1 -\/ For each contour value, all cells are processed. This order should be used if the extracted polygons must be rendered in a back-\/to-\/front or front-\/to-\/back order. This is very problem dependent. For most applications, the default order is fine (and faster).

Sort by cell is going to have a problem if the input has 2\-D and 3\-D cells. Cell data will be scrambled becauses with vtk\-Poly\-Data output, verts and lines have lower cell ids than triangles.  
\item {\ttfamily int = obj.\-Get\-Sort\-By ()} -\/ Set the sorting order for the generated polydata. There are two possibilities\-: Sort by value = 0 -\/ This is the most efficient sort. For each cell, all contour values are processed. This is the default. Sort by cell = 1 -\/ For each contour value, all cells are processed. This order should be used if the extracted polygons must be rendered in a back-\/to-\/front or front-\/to-\/back order. This is very problem dependent. For most applications, the default order is fine (and faster).

Sort by cell is going to have a problem if the input has 2\-D and 3\-D cells. Cell data will be scrambled becauses with vtk\-Poly\-Data output, verts and lines have lower cell ids than triangles.  
\item {\ttfamily obj.\-Set\-Sort\-By\-To\-Sort\-By\-Value ()} -\/ Set the sorting order for the generated polydata. There are two possibilities\-: Sort by value = 0 -\/ This is the most efficient sort. For each cell, all contour values are processed. This is the default. Sort by cell = 1 -\/ For each contour value, all cells are processed. This order should be used if the extracted polygons must be rendered in a back-\/to-\/front or front-\/to-\/back order. This is very problem dependent. For most applications, the default order is fine (and faster).

Sort by cell is going to have a problem if the input has 2\-D and 3\-D cells. Cell data will be scrambled becauses with vtk\-Poly\-Data output, verts and lines have lower cell ids than triangles.  
\item {\ttfamily obj.\-Set\-Sort\-By\-To\-Sort\-By\-Cell ()} -\/ Return the sorting procedure as a descriptive character string.  
\item {\ttfamily string = obj.\-Get\-Sort\-By\-As\-String ()} -\/ Create default locator. Used to create one when none is specified. The locator is used to merge coincident points.  
\item {\ttfamily obj.\-Create\-Default\-Locator ()} -\/ Create default locator. Used to create one when none is specified. The locator is used to merge coincident points.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkhyperoctreedepth}{}\section{vtk\-Hyper\-Octree\-Depth}\label{vtkgraphics_vtkhyperoctreedepth}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This filter returns a shallow copy of its input Hyper\-Octree with a new data attribute field containing the depth of each cell.

To create an instance of class vtk\-Hyper\-Octree\-Depth, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHyperOctreeDepth
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Hyper\-Octree\-Depth has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Hyper\-Octree\-Depth class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Hyper\-Octree\-Depth = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Hyper\-Octree\-Depth = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkhyperoctreedualgridcontourfilter}{}\section{vtk\-Hyper\-Octree\-Dual\-Grid\-Contour\-Filter}\label{vtkgraphics_vtkhyperoctreedualgridcontourfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
use of unsigned short to hold level index limits tree depth to 16.

To use this filter you must specify one or more contour values. You can either use the method Set\-Value() to specify each contour value, or use Generate\-Values() to generate a series of evenly spaced contours. It is also possible to accelerate the operation of this filter (at the cost of extra memory) by using a vtk\-Scalar\-Tree. A scalar tree is used to quickly locate cells that contain a contour surface. This is especially effective if multiple contours are being extracted. If you want to use a scalar tree, invoke the method Use\-Scalar\-Tree\-On().

To create an instance of class vtk\-Hyper\-Octree\-Dual\-Grid\-Contour\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHyperOctreeDualGridContourFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Hyper\-Octree\-Dual\-Grid\-Contour\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Hyper\-Octree\-Dual\-Grid\-Contour\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Hyper\-Octree\-Dual\-Grid\-Contour\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Hyper\-Octree\-Dual\-Grid\-Contour\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Value (int i, double value)} -\/ Get the ith contour value.  
\item {\ttfamily double = obj.\-Get\-Value (int i)} -\/ Get a pointer to an array of contour values. There will be Get\-Number\-Of\-Contours() values in the list.  
\item {\ttfamily obj.\-Get\-Values (double contour\-Values)} -\/ Set the number of contours to place into the list. You only really need to use this method to reduce list size. The method Set\-Value() will automatically increase list size as needed.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Contours (int number)} -\/ Get the number of contours in the list of contour values.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Contours ()} -\/ Generate num\-Contours equally spaced contour values between specified range. Contour values will include min/max range values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\mbox{[}2\mbox{]})} -\/ Generate num\-Contours equally spaced contour values between specified range. Contour values will include min/max range values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\-Start, double range\-End)} -\/ Modified Get\-M\-Time Because we delegate to vtk\-Contour\-Values  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Modified Get\-M\-Time Because we delegate to vtk\-Contour\-Values  
\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. The locator is used to merge coincident points.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkhyperoctreefractalsource}{}\section{vtk\-Hyper\-Octree\-Fractal\-Source}\label{vtkgraphics_vtkhyperoctreefractalsource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
To create an instance of class vtk\-Hyper\-Octree\-Fractal\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHyperOctreeFractalSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Hyper\-Octree\-Fractal\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Hyper\-Octree\-Fractal\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Hyper\-Octree\-Fractal\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Hyper\-Octree\-Fractal\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Maximum\-Level ()} -\/ Return the maximum number of levels of the hyperoctree. \begin{DoxyPostcond}{Postcondition}
positive\-\_\-result\-: result$>$=1  
\end{DoxyPostcond}

\item {\ttfamily obj.\-Set\-Maximum\-Level (int levels)} -\/ Set the maximum number of levels of the hyperoctree. If Get\-Min\-Levels()$>$=levels, Get\-Min\-Levels() is changed to levels-\/1. \begin{DoxyPrecond}{Precondition}
positive\-\_\-levels\-: levels$>$=1 
\end{DoxyPrecond}
\begin{DoxyPostcond}{Postcondition}
is\-\_\-set\-: this-\/$>$Get\-Levels()==levels 

min\-\_\-is\-\_\-valid\-: this-\/$>$Get\-Min\-Levels()$<$this-\/$>$Get\-Levels()  
\end{DoxyPostcond}

\item {\ttfamily obj.\-Set\-Minimum\-Level (int level)} -\/ Return the minimal number of levels of systematic subdivision. \begin{DoxyPostcond}{Postcondition}
positive\-\_\-result\-: result$>$=0  
\end{DoxyPostcond}

\item {\ttfamily int = obj.\-Get\-Minimum\-Level ()} -\/ Return the minimal number of levels of systematic subdivision. \begin{DoxyPostcond}{Postcondition}
positive\-\_\-result\-: result$>$=0  
\end{DoxyPostcond}

\item {\ttfamily obj.\-Set\-Projection\-Axes (int x, int y, int z)} -\/ Set the projection from the 4\-D space (4 parameters / 2 imaginary numbers) to the axes of the 3\-D Volume. 0=C\-\_\-\-Real, 1=C\-\_\-\-Imaginary, 2=X\-\_\-\-Real, 4=X\-\_\-\-Imaginary  
\item {\ttfamily obj.\-Set\-Projection\-Axes (int a\mbox{[}3\mbox{]})} -\/ Set the projection from the 4\-D space (4 parameters / 2 imaginary numbers) to the axes of the 3\-D Volume. 0=C\-\_\-\-Real, 1=C\-\_\-\-Imaginary, 2=X\-\_\-\-Real, 4=X\-\_\-\-Imaginary  
\item {\ttfamily int = obj. Get\-Projection\-Axes ()} -\/ Set the projection from the 4\-D space (4 parameters / 2 imaginary numbers) to the axes of the 3\-D Volume. 0=C\-\_\-\-Real, 1=C\-\_\-\-Imaginary, 2=X\-\_\-\-Real, 4=X\-\_\-\-Imaginary  
\item {\ttfamily obj.\-Set\-Origin\-C\-X (double , double , double , double )} -\/ Imaginary and real value for C (constant in equation) and X (initial value).  
\item {\ttfamily obj.\-Set\-Origin\-C\-X (double a\mbox{[}4\mbox{]})} -\/ Imaginary and real value for C (constant in equation) and X (initial value).  
\item {\ttfamily double = obj. Get\-Origin\-C\-X ()} -\/ Imaginary and real value for C (constant in equation) and X (initial value).  
\item {\ttfamily obj.\-Set\-Size\-C\-X (double , double , double , double )} -\/ Just a different way of setting the sample. This sets the size of the 4\-D volume. Sample\-C\-X is computed from size and extent. Size is ignored when a dimension i 0 (collapsed).  
\item {\ttfamily obj.\-Set\-Size\-C\-X (double a\mbox{[}4\mbox{]})} -\/ Just a different way of setting the sample. This sets the size of the 4\-D volume. Sample\-C\-X is computed from size and extent. Size is ignored when a dimension i 0 (collapsed).  
\item {\ttfamily double = obj. Get\-Size\-C\-X ()} -\/ Just a different way of setting the sample. This sets the size of the 4\-D volume. Sample\-C\-X is computed from size and extent. Size is ignored when a dimension i 0 (collapsed).  
\item {\ttfamily obj.\-Set\-Maximum\-Number\-Of\-Iterations (short )} -\/ The maximum number of cycles run to see if the value goes over 2  
\item {\ttfamily Get\-Maximum\-Number\-Of\-Iterations\-Min\-Value = obj.()} -\/ The maximum number of cycles run to see if the value goes over 2  
\item {\ttfamily Get\-Maximum\-Number\-Of\-Iterations\-Max\-Value = obj.()} -\/ The maximum number of cycles run to see if the value goes over 2  
\item {\ttfamily char = obj.\-Get\-Maximum\-Number\-Of\-Iterations ()} -\/ The maximum number of cycles run to see if the value goes over 2  
\item {\ttfamily obj.\-Set\-Dimension (int )} -\/ Create a 2\-D or 3\-D fractal.  
\item {\ttfamily int = obj.\-Get\-Dimension\-Min\-Value ()} -\/ Create a 2\-D or 3\-D fractal.  
\item {\ttfamily int = obj.\-Get\-Dimension\-Max\-Value ()} -\/ Create a 2\-D or 3\-D fractal.  
\item {\ttfamily int = obj.\-Get\-Dimension ()} -\/ Create a 2\-D or 3\-D fractal.  
\item {\ttfamily obj.\-Set\-Span\-Threshold (double )} -\/ Controls when a leaf gets subdivided. If the corner values span a larger range than this value, the leaf is subdivided. This defaults to 2.  
\item {\ttfamily double = obj.\-Get\-Span\-Threshold ()} -\/ Controls when a leaf gets subdivided. If the corner values span a larger range than this value, the leaf is subdivided. This defaults to 2.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkhyperoctreelimiter}{}\section{vtk\-Hyper\-Octree\-Limiter}\label{vtkgraphics_vtkhyperoctreelimiter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This filter returns a lower resolution copy of its input vtk\-Hyper\-Octree. It does a length/area/volume weighted averaging to obtain data at each cut point. Above the cut level, leaf attribute data is simply copied.

To create an instance of class vtk\-Hyper\-Octree\-Limiter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHyperOctreeLimiter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Hyper\-Octree\-Limiter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Hyper\-Octree\-Limiter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Hyper\-Octree\-Limiter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Hyper\-Octree\-Limiter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Maximum\-Level ()} -\/ Return the maximum number of levels of the hyperoctree.  
\item {\ttfamily obj.\-Set\-Maximum\-Level (int levels)} -\/ Set the maximum number of levels of the hyperoctree.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkhyperoctreesamplefunction}{}\section{vtk\-Hyper\-Octree\-Sample\-Function}\label{vtkgraphics_vtkhyperoctreesamplefunction}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Hyper\-Octree\-Sample\-Function is a source object that evaluates an implicit function to drive the subdivision process. The user can specify the threshold over which a subdivision occurs, the maximum and minimum level of subdivisions and the dimension of the hyperoctree.

To create an instance of class vtk\-Hyper\-Octree\-Sample\-Function, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHyperOctreeSampleFunction
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Hyper\-Octree\-Sample\-Function has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Hyper\-Octree\-Sample\-Function class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Hyper\-Octree\-Sample\-Function = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Hyper\-Octree\-Sample\-Function = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Levels ()} -\/ Return the maximum number of levels of the hyperoctree. \begin{DoxyPostcond}{Postcondition}
positive\-\_\-result\-: result$>$=1  
\end{DoxyPostcond}

\item {\ttfamily obj.\-Set\-Levels (int levels)} -\/ Set the maximum number of levels of the hyperoctree. If Get\-Min\-Levels()$>$=levels, Get\-Min\-Levels() is changed to levels-\/1. \begin{DoxyPrecond}{Precondition}
positive\-\_\-levels\-: levels$>$=1 
\end{DoxyPrecond}
\begin{DoxyPostcond}{Postcondition}
is\-\_\-set\-: this-\/$>$Get\-Levels()==levels 

min\-\_\-is\-\_\-valid\-: this-\/$>$Get\-Min\-Levels()$<$this-\/$>$Get\-Levels()  
\end{DoxyPostcond}

\item {\ttfamily int = obj.\-Get\-Min\-Levels ()} -\/ Return the minimal number of levels of systematic subdivision. \begin{DoxyPostcond}{Postcondition}
positive\-\_\-result\-: result$>$=0  
\end{DoxyPostcond}

\item {\ttfamily obj.\-Set\-Min\-Levels (int min\-Levels)} -\/ Set the minimal number of levels of systematic subdivision. \begin{DoxyPrecond}{Precondition}
positive\-\_\-min\-Levels\-: min\-Levels$>$=0 
\end{DoxyPrecond}
\begin{DoxyPostcond}{Postcondition}
is\-\_\-set\-: this-\/$>$Get\-Min\-Levels()==min\-Levels  
\end{DoxyPostcond}

\item {\ttfamily double = obj.\-Get\-Threshold ()} -\/ Return the threshold over which a subdivision is required. \begin{DoxyPostcond}{Postcondition}
positive\-\_\-result\-: result$>$0  
\end{DoxyPostcond}

\item {\ttfamily obj.\-Set\-Threshold (double threshold)} -\/ Set the threshold over which a subdivision is required. \begin{DoxyPrecond}{Precondition}
positive\-\_\-threshold\-: threshold$>$=0 
\end{DoxyPrecond}
\begin{DoxyPostcond}{Postcondition}
is\-\_\-set\-: this-\/$>$Get\-Threshold()==threshold  
\end{DoxyPostcond}

\item {\ttfamily int = obj.\-Get\-Dimension ()} -\/ Return the dimension of the tree (1\-D\-:binary tree(2 children), 2\-D\-:quadtree(4 children), 3\-D\-:octree (8 children)) \begin{DoxyPostcond}{Postcondition}
valid\-\_\-result\-: result$>$=1 \&\& result$<$=3  
\end{DoxyPostcond}

\item {\ttfamily obj.\-Set\-Dimension (int dim)}  
\item {\ttfamily obj.\-Set\-Size (double , double , double )} -\/ Set the size on each axis.  
\item {\ttfamily obj.\-Set\-Size (double a\mbox{[}3\mbox{]})} -\/ Set the size on each axis.  
\item {\ttfamily double = obj. Get\-Size ()} -\/ Return the size on each axis.  
\item {\ttfamily obj.\-Set\-Origin (double , double , double )} -\/ Set the origin (position of corner (0,0,0) of the root.  
\item {\ttfamily obj.\-Set\-Origin (double a\mbox{[}3\mbox{]})} -\/ Set the origin (position of corner (0,0,0) of the root.  
\item {\ttfamily double = obj. Get\-Origin ()} -\/ Set the origin (position of corner (0,0,0) of the root. Return the origin (position of corner (0,0,0) ) of the root.  
\item {\ttfamily double = obj.\-Get\-Width ()} -\/ Return the length along the x-\/axis. \begin{DoxyPostcond}{Postcondition}
positive\-\_\-result\-: result$>$0  
\end{DoxyPostcond}

\item {\ttfamily obj.\-Set\-Width (double width)} -\/ Set the length along the x-\/axis. \begin{DoxyPrecond}{Precondition}
positive\-\_\-width\-: width$>$0 
\end{DoxyPrecond}
\begin{DoxyPostcond}{Postcondition}
width\-\_\-is\-\_\-set\-: Get\-Width()==width  
\end{DoxyPostcond}

\item {\ttfamily double = obj.\-Get\-Height ()} -\/ Return the length along the y-\/axis. Relevant only if Get\-Dimension()$>$=2 \begin{DoxyPostcond}{Postcondition}
positive\-\_\-result\-: result$>$0  
\end{DoxyPostcond}

\item {\ttfamily obj.\-Set\-Height (double height)} -\/ Set the length along the y-\/axis. Relevant only if Get\-Dimension()$>$=2 \begin{DoxyPrecond}{Precondition}
positive\-\_\-height\-: height$>$0 
\end{DoxyPrecond}
\begin{DoxyPostcond}{Postcondition}
height\-\_\-is\-\_\-set\-: Get\-Height()==height  
\end{DoxyPostcond}

\item {\ttfamily double = obj.\-Get\-Depth ()} -\/ Return the length along the z-\/axis. Relevant only if Get\-Dimension()$>$=3 \begin{DoxyPostcond}{Postcondition}
positive\-\_\-result\-: result$>$0  
\end{DoxyPostcond}

\item {\ttfamily obj.\-Set\-Depth (double depth)} -\/ Return the length along the z-\/axis. Relevant only if Get\-Dimension()$>$=3 \begin{DoxyPrecond}{Precondition}
positive\-\_\-depth\-: depth$>$0 
\end{DoxyPrecond}
\begin{DoxyPostcond}{Postcondition}
depth\-\_\-is\-\_\-set\-: Get\-Depth()==depth  
\end{DoxyPostcond}

\item {\ttfamily obj.\-Set\-Implicit\-Function (vtk\-Implicit\-Function )} -\/ Specify the implicit function to use to generate data.  
\item {\ttfamily vtk\-Implicit\-Function = obj.\-Get\-Implicit\-Function ()} -\/ Specify the implicit function to use to generate data.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type (int )} -\/ Set what type of scalar data this source should generate.  
\item {\ttfamily int = obj.\-Get\-Output\-Scalar\-Type ()} -\/ Set what type of scalar data this source should generate.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Double ()} -\/ Set what type of scalar data this source should generate.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Float ()} -\/ Set what type of scalar data this source should generate.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Long ()} -\/ Set what type of scalar data this source should generate.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Unsigned\-Long ()} -\/ Set what type of scalar data this source should generate.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Int ()} -\/ Set what type of scalar data this source should generate.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Unsigned\-Int ()} -\/ Set what type of scalar data this source should generate.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Short ()} -\/ Set what type of scalar data this source should generate.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Unsigned\-Short ()} -\/ Set what type of scalar data this source should generate.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Char ()} -\/ Set what type of scalar data this source should generate.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Unsigned\-Char ()} -\/ Return the M\-Time also considering the implicit function.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return the M\-Time also considering the implicit function.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkhyperoctreesurfacefilter}{}\section{vtk\-Hyper\-Octree\-Surface\-Filter}\label{vtkgraphics_vtkhyperoctreesurfacefilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Hyper\-Octree\-Surface\-Filter extracts the surface of an hyperoctree.

To create an instance of class vtk\-Hyper\-Octree\-Surface\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHyperOctreeSurfaceFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Hyper\-Octree\-Surface\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Hyper\-Octree\-Surface\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Hyper\-Octree\-Surface\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Hyper\-Octree\-Surface\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Merging (int )} -\/ Turn on/off merging of coincident points. Note that is merging is on, points with different point attributes (e.\-g., normals) are merged, which may cause rendering artifacts.  
\item {\ttfamily int = obj.\-Get\-Merging ()} -\/ Turn on/off merging of coincident points. Note that is merging is on, points with different point attributes (e.\-g., normals) are merged, which may cause rendering artifacts.  
\item {\ttfamily obj.\-Merging\-On ()} -\/ Turn on/off merging of coincident points. Note that is merging is on, points with different point attributes (e.\-g., normals) are merged, which may cause rendering artifacts.  
\item {\ttfamily obj.\-Merging\-Off ()} -\/ Turn on/off merging of coincident points. Note that is merging is on, points with different point attributes (e.\-g., normals) are merged, which may cause rendering artifacts.  
\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 long = obj.\-Get\-M\-Time ()} -\/ Return the M\-Time also considering the locator.  
\item {\ttfamily obj.\-Set\-Pass\-Through\-Cell\-Ids (int )} -\/ If on, the output polygonal dataset will have a celldata array that holds the cell index of the original 3\-D cell that produced each output cell. This is useful for cell picking. The default is off to conserve memory.  
\item {\ttfamily int = obj.\-Get\-Pass\-Through\-Cell\-Ids ()} -\/ If on, the output polygonal dataset will have a celldata array that holds the cell index of the original 3\-D cell that produced each output cell. This is useful for cell picking. The default is off to conserve memory.  
\item {\ttfamily obj.\-Pass\-Through\-Cell\-Ids\-On ()} -\/ If on, the output polygonal dataset will have a celldata array that holds the cell index of the original 3\-D cell that produced each output cell. This is useful for cell picking. The default is off to conserve memory.  
\item {\ttfamily obj.\-Pass\-Through\-Cell\-Ids\-Off ()} -\/ If on, the output polygonal dataset will have a celldata array that holds the cell index of the original 3\-D cell that produced each output cell. This is useful for cell picking. The default is off to conserve memory.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkhyperoctreetouniformgridfilter}{}\section{vtk\-Hyper\-Octree\-To\-Uniform\-Grid\-Filter}\label{vtkgraphics_vtkhyperoctreetouniformgridfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Hyper\-Octree\-To\-Uniform\-Grid\-Filter creates a uniform grid with a resolution based on the number of levels of the hyperoctree. Then, it copies celldata in each cell of the uniform grid that belongs to an actual leaf of the hyperoctree.

To create an instance of class vtk\-Hyper\-Octree\-To\-Uniform\-Grid\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHyperOctreeToUniformGridFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Hyper\-Octree\-To\-Uniform\-Grid\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Hyper\-Octree\-To\-Uniform\-Grid\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Hyper\-Octree\-To\-Uniform\-Grid\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Hyper\-Octree\-To\-Uniform\-Grid\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkhyperstreamline}{}\section{vtk\-Hyper\-Streamline}\label{vtkgraphics_vtkhyperstreamline}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Hyper\-Streamline is a filter that integrates through a tensor field to generate a hyperstreamline. The integration is along the maximum eigenvector and the cross section of the hyperstreamline is defined by the two other eigenvectors. Thus the shape of the hyperstreamline is \char`\"{}tube-\/like\char`\"{}, with the cross section being elliptical. Hyperstreamlines are used to visualize tensor fields.

The starting point of a hyperstreamline can be defined in one of two ways. First, you may specify an initial position. This is a x-\/y-\/z global coordinate. The second option is to specify a starting location. This is cell\-Id, sub\-Id, and cell parametric coordinates.

The integration of the hyperstreamline occurs through the major eigenvector field. Integration\-Step\-Length controls the step length within each cell (i.\-e., this is the fraction of the cell length). The length of the hyperstreamline is controlled by Maximum\-Propagation\-Distance. This parameter is the length of the hyperstreamline in units of distance. The tube itself is composed of many small sub-\/tubes -\/ Number\-Of\-Sides controls the number of sides in the tube, and Step\-Length controls the length of the sub-\/tubes.

Because hyperstreamlines are often created near regions of singularities, it is possible to control the scaling of the tube cross section by using a logarithmic scale. Use Log\-Scaling\-On to turn this capability on. The Radius value controls the initial radius of the tube.

To create an instance of class vtk\-Hyper\-Streamline, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHyperStreamline
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Hyper\-Streamline has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Hyper\-Streamline class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Hyper\-Streamline = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Hyper\-Streamline = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Start\-Location (vtk\-Id\-Type cell\-Id, int sub\-Id, double pcoords\mbox{[}3\mbox{]})} -\/ Specify the start of the hyperstreamline in the cell coordinate system. That is, cell\-Id and sub\-Id (if composite cell), and parametric coordinates.  
\item {\ttfamily obj.\-Set\-Start\-Location (vtk\-Id\-Type cell\-Id, int sub\-Id, double r, double s, double t)} -\/ Specify the start of the hyperstreamline in the cell coordinate system. That is, cell\-Id and sub\-Id (if composite cell), and parametric coordinates.  
\item {\ttfamily obj.\-Set\-Start\-Position (double x\mbox{[}3\mbox{]})} -\/ Specify the start of the hyperstreamline in the global coordinate system. Starting from position implies that a search must be performed to find initial cell to start integration from.  
\item {\ttfamily obj.\-Set\-Start\-Position (double x, double y, double z)} -\/ Specify the start of the hyperstreamline in the global coordinate system. Starting from position implies that a search must be performed to find initial cell to start integration from.  
\item {\ttfamily double = obj.\-Get\-Start\-Position ()} -\/ Get the start position of the hyperstreamline in global x-\/y-\/z coordinates.  
\item {\ttfamily obj.\-Set\-Maximum\-Propagation\-Distance (double )} -\/ Set / get the maximum length of the hyperstreamline expressed as absolute distance (i.\-e., arc length) value.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Propagation\-Distance\-Min\-Value ()} -\/ Set / get the maximum length of the hyperstreamline expressed as absolute distance (i.\-e., arc length) value.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Propagation\-Distance\-Max\-Value ()} -\/ Set / get the maximum length of the hyperstreamline expressed as absolute distance (i.\-e., arc length) value.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Propagation\-Distance ()} -\/ Set / get the maximum length of the hyperstreamline expressed as absolute distance (i.\-e., arc length) value.  
\item {\ttfamily obj.\-Set\-Integration\-Eigenvector (int )} -\/ Set / get the eigenvector field through which to ingrate. It is possible to integrate using the major, medium or minor eigenvector field. The major eigenvector is the eigenvector whose corresponding eigenvalue is closest to positive infinity. The minor eigenvector is the eigenvector whose corresponding eigenvalue is closest to negative infinity. The medium eigenvector is the eigenvector whose corresponding eigenvalue is between the major and minor eigenvalues.  
\item {\ttfamily int = obj.\-Get\-Integration\-Eigenvector\-Min\-Value ()} -\/ Set / get the eigenvector field through which to ingrate. It is possible to integrate using the major, medium or minor eigenvector field. The major eigenvector is the eigenvector whose corresponding eigenvalue is closest to positive infinity. The minor eigenvector is the eigenvector whose corresponding eigenvalue is closest to negative infinity. The medium eigenvector is the eigenvector whose corresponding eigenvalue is between the major and minor eigenvalues.  
\item {\ttfamily int = obj.\-Get\-Integration\-Eigenvector\-Max\-Value ()} -\/ Set / get the eigenvector field through which to ingrate. It is possible to integrate using the major, medium or minor eigenvector field. The major eigenvector is the eigenvector whose corresponding eigenvalue is closest to positive infinity. The minor eigenvector is the eigenvector whose corresponding eigenvalue is closest to negative infinity. The medium eigenvector is the eigenvector whose corresponding eigenvalue is between the major and minor eigenvalues.  
\item {\ttfamily int = obj.\-Get\-Integration\-Eigenvector ()} -\/ Set / get the eigenvector field through which to ingrate. It is possible to integrate using the major, medium or minor eigenvector field. The major eigenvector is the eigenvector whose corresponding eigenvalue is closest to positive infinity. The minor eigenvector is the eigenvector whose corresponding eigenvalue is closest to negative infinity. The medium eigenvector is the eigenvector whose corresponding eigenvalue is between the major and minor eigenvalues.  
\item {\ttfamily obj.\-Set\-Integration\-Eigenvector\-To\-Major ()} -\/ Set / get the eigenvector field through which to ingrate. It is possible to integrate using the major, medium or minor eigenvector field. The major eigenvector is the eigenvector whose corresponding eigenvalue is closest to positive infinity. The minor eigenvector is the eigenvector whose corresponding eigenvalue is closest to negative infinity. The medium eigenvector is the eigenvector whose corresponding eigenvalue is between the major and minor eigenvalues.  
\item {\ttfamily obj.\-Set\-Integration\-Eigenvector\-To\-Medium ()} -\/ Set / get the eigenvector field through which to ingrate. It is possible to integrate using the major, medium or minor eigenvector field. The major eigenvector is the eigenvector whose corresponding eigenvalue is closest to positive infinity. The minor eigenvector is the eigenvector whose corresponding eigenvalue is closest to negative infinity. The medium eigenvector is the eigenvector whose corresponding eigenvalue is between the major and minor eigenvalues.  
\item {\ttfamily obj.\-Set\-Integration\-Eigenvector\-To\-Minor ()} -\/ Set / get the eigenvector field through which to ingrate. It is possible to integrate using the major, medium or minor eigenvector field. The major eigenvector is the eigenvector whose corresponding eigenvalue is closest to positive infinity. The minor eigenvector is the eigenvector whose corresponding eigenvalue is closest to negative infinity. The medium eigenvector is the eigenvector whose corresponding eigenvalue is between the major and minor eigenvalues.  
\item {\ttfamily obj.\-Integrate\-Major\-Eigenvector ()} -\/ Use the major eigenvector field as the vector field through which to integrate. The major eigenvector is the eigenvector whose corresponding eigenvalue is closest to positive infinity.  
\item {\ttfamily obj.\-Integrate\-Medium\-Eigenvector ()} -\/ Use the medium eigenvector field as the vector field through which to integrate. The medium eigenvector is the eigenvector whose corresponding eigenvalue is between the major and minor eigenvalues.  
\item {\ttfamily obj.\-Integrate\-Minor\-Eigenvector ()} -\/ Use the minor eigenvector field as the vector field through which to integrate. The minor eigenvector is the eigenvector whose corresponding eigenvalue is closest to negative infinity.  
\item {\ttfamily obj.\-Set\-Integration\-Step\-Length (double )} -\/ Set / get a nominal integration step size (expressed as a fraction of the size of each cell).  
\item {\ttfamily double = obj.\-Get\-Integration\-Step\-Length\-Min\-Value ()} -\/ Set / get a nominal integration step size (expressed as a fraction of the size of each cell).  
\item {\ttfamily double = obj.\-Get\-Integration\-Step\-Length\-Max\-Value ()} -\/ Set / get a nominal integration step size (expressed as a fraction of the size of each cell).  
\item {\ttfamily double = obj.\-Get\-Integration\-Step\-Length ()} -\/ Set / get a nominal integration step size (expressed as a fraction of the size of each cell).  
\item {\ttfamily obj.\-Set\-Step\-Length (double )} -\/ Set / get the length of a tube segment composing the hyperstreamline. The length is specified as a fraction of the diagonal length of the input bounding box.  
\item {\ttfamily double = obj.\-Get\-Step\-Length\-Min\-Value ()} -\/ Set / get the length of a tube segment composing the hyperstreamline. The length is specified as a fraction of the diagonal length of the input bounding box.  
\item {\ttfamily double = obj.\-Get\-Step\-Length\-Max\-Value ()} -\/ Set / get the length of a tube segment composing the hyperstreamline. The length is specified as a fraction of the diagonal length of the input bounding box.  
\item {\ttfamily double = obj.\-Get\-Step\-Length ()} -\/ Set / get the length of a tube segment composing the hyperstreamline. The length is specified as a fraction of the diagonal length of the input bounding box.  
\item {\ttfamily obj.\-Set\-Integration\-Direction (int )} -\/ Specify the direction in which to integrate the hyperstreamline.  
\item {\ttfamily int = obj.\-Get\-Integration\-Direction\-Min\-Value ()} -\/ Specify the direction in which to integrate the hyperstreamline.  
\item {\ttfamily int = obj.\-Get\-Integration\-Direction\-Max\-Value ()} -\/ Specify the direction in which to integrate the hyperstreamline.  
\item {\ttfamily int = obj.\-Get\-Integration\-Direction ()} -\/ Specify the direction in which to integrate the hyperstreamline.  
\item {\ttfamily obj.\-Set\-Integration\-Direction\-To\-Forward ()} -\/ Specify the direction in which to integrate the hyperstreamline.  
\item {\ttfamily obj.\-Set\-Integration\-Direction\-To\-Backward ()} -\/ Specify the direction in which to integrate the hyperstreamline.  
\item {\ttfamily obj.\-Set\-Integration\-Direction\-To\-Integrate\-Both\-Directions ()} -\/ Specify the direction in which to integrate the hyperstreamline.  
\item {\ttfamily obj.\-Set\-Terminal\-Eigenvalue (double )} -\/ Set/get terminal eigenvalue. If major eigenvalue falls below this value, hyperstreamline terminates propagation.  
\item {\ttfamily double = obj.\-Get\-Terminal\-Eigenvalue\-Min\-Value ()} -\/ Set/get terminal eigenvalue. If major eigenvalue falls below this value, hyperstreamline terminates propagation.  
\item {\ttfamily double = obj.\-Get\-Terminal\-Eigenvalue\-Max\-Value ()} -\/ Set/get terminal eigenvalue. If major eigenvalue falls below this value, hyperstreamline terminates propagation.  
\item {\ttfamily double = obj.\-Get\-Terminal\-Eigenvalue ()} -\/ Set/get terminal eigenvalue. If major eigenvalue falls below this value, hyperstreamline terminates propagation.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Sides (int )} -\/ Set / get the number of sides for the hyperstreamlines. At a minimum, number of sides is 3.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Sides\-Min\-Value ()} -\/ Set / get the number of sides for the hyperstreamlines. At a minimum, number of sides is 3.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Sides\-Max\-Value ()} -\/ Set / get the number of sides for the hyperstreamlines. At a minimum, number of sides is 3.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Sides ()} -\/ Set / get the number of sides for the hyperstreamlines. At a minimum, number of sides is 3.  
\item {\ttfamily obj.\-Set\-Radius (double )} -\/ Set / get the initial tube radius. This is the maximum \char`\"{}elliptical\char`\"{} radius at the beginning of the tube. Radius varies based on ratio of eigenvalues. Note that tube section is actually elliptical and may become a point or line in cross section in some cases.  
\item {\ttfamily double = obj.\-Get\-Radius\-Min\-Value ()} -\/ Set / get the initial tube radius. This is the maximum \char`\"{}elliptical\char`\"{} radius at the beginning of the tube. Radius varies based on ratio of eigenvalues. Note that tube section is actually elliptical and may become a point or line in cross section in some cases.  
\item {\ttfamily double = obj.\-Get\-Radius\-Max\-Value ()} -\/ Set / get the initial tube radius. This is the maximum \char`\"{}elliptical\char`\"{} radius at the beginning of the tube. Radius varies based on ratio of eigenvalues. Note that tube section is actually elliptical and may become a point or line in cross section in some cases.  
\item {\ttfamily double = obj.\-Get\-Radius ()} -\/ Set / get the initial tube radius. This is the maximum \char`\"{}elliptical\char`\"{} radius at the beginning of the tube. Radius varies based on ratio of eigenvalues. Note that tube section is actually elliptical and may become a point or line in cross section in some cases.  
\item {\ttfamily obj.\-Set\-Log\-Scaling (int )} -\/ Turn on/off logarithmic scaling. If scaling is on, the log base 10 of the computed eigenvalues are used to scale the cross section radii.  
\item {\ttfamily int = obj.\-Get\-Log\-Scaling ()} -\/ Turn on/off logarithmic scaling. If scaling is on, the log base 10 of the computed eigenvalues are used to scale the cross section radii.  
\item {\ttfamily obj.\-Log\-Scaling\-On ()} -\/ Turn on/off logarithmic scaling. If scaling is on, the log base 10 of the computed eigenvalues are used to scale the cross section radii.  
\item {\ttfamily obj.\-Log\-Scaling\-Off ()} -\/ Turn on/off logarithmic scaling. If scaling is on, the log base 10 of the computed eigenvalues are used to scale the cross section radii.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkiconglyphfilter}{}\section{vtk\-Icon\-Glyph\-Filter}\label{vtkgraphics_vtkiconglyphfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Icon\-Glyph\-Filter takes in a vtk\-Point\-Set where each point corresponds to the center of an icon. Scalar integer data must also be set to give each point an icon index. This index is a zero based row major index into an image that contains a grid of icons. You must also set pixel Size of the icon image and the size of a particular icon.

To create an instance of class vtk\-Icon\-Glyph\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkIconGlyphFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Icon\-Glyph\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Icon\-Glyph\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Icon\-Glyph\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Icon\-Glyph\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Icon\-Size (int , int )} -\/ Specify the Width and Height, in pixels, of an icon in the icon sheet  
\item {\ttfamily obj.\-Set\-Icon\-Size (int a\mbox{[}2\mbox{]})} -\/ Specify the Width and Height, in pixels, of an icon in the icon sheet  
\item {\ttfamily int = obj. Get\-Icon\-Size ()} -\/ Specify the Width and Height, in pixels, of an icon in the icon sheet  
\item {\ttfamily obj.\-Set\-Icon\-Sheet\-Size (int , int )} -\/ Specify the Width and Height, in pixels, of an icon in the icon sheet  
\item {\ttfamily obj.\-Set\-Icon\-Sheet\-Size (int a\mbox{[}2\mbox{]})} -\/ Specify the Width and Height, in pixels, of an icon in the icon sheet  
\item {\ttfamily int = obj. Get\-Icon\-Sheet\-Size ()} -\/ Specify the Width and Height, in pixels, of an icon in the icon sheet  
\item {\ttfamily obj.\-Set\-Use\-Icon\-Size (bool b)} -\/ Specify whether the Quad generated to place the icon on will be either 1 x 1 or the dimensions specified by Icon\-Size.  
\item {\ttfamily bool = obj.\-Get\-Use\-Icon\-Size ()} -\/ Specify whether the Quad generated to place the icon on will be either 1 x 1 or the dimensions specified by Icon\-Size.  
\item {\ttfamily obj.\-Use\-Icon\-Size\-On ()} -\/ Specify whether the Quad generated to place the icon on will be either 1 x 1 or the dimensions specified by Icon\-Size.  
\item {\ttfamily obj.\-Use\-Icon\-Size\-Off ()} -\/ Specify whether the Quad generated to place the icon on will be either 1 x 1 or the dimensions specified by Icon\-Size.  
\item {\ttfamily obj.\-Set\-Gravity (int )} -\/ Specify if the input points define the center of the icon quad or one of top right corner, top center, top left corner, center right, center, center center left, bottom right corner, bottom center or bottom left corner.  
\item {\ttfamily int = obj.\-Get\-Gravity ()} -\/ Specify if the input points define the center of the icon quad or one of top right corner, top center, top left corner, center right, center, center center left, bottom right corner, bottom center or bottom left corner.  
\item {\ttfamily obj.\-Set\-Gravity\-To\-Top\-Right ()} -\/ Specify if the input points define the center of the icon quad or one of top right corner, top center, top left corner, center right, center, center center left, bottom right corner, bottom center or bottom left corner.  
\item {\ttfamily obj.\-Set\-Gravity\-To\-Top\-Center ()} -\/ Specify if the input points define the center of the icon quad or one of top right corner, top center, top left corner, center right, center, center center left, bottom right corner, bottom center or bottom left corner.  
\item {\ttfamily obj.\-Set\-Gravity\-To\-Top\-Left ()} -\/ Specify if the input points define the center of the icon quad or one of top right corner, top center, top left corner, center right, center, center center left, bottom right corner, bottom center or bottom left corner.  
\item {\ttfamily obj.\-Set\-Gravity\-To\-Center\-Right ()} -\/ Specify if the input points define the center of the icon quad or one of top right corner, top center, top left corner, center right, center, center center left, bottom right corner, bottom center or bottom left corner.  
\item {\ttfamily obj.\-Set\-Gravity\-To\-Center\-Center ()} -\/ Specify if the input points define the center of the icon quad or one of top right corner, top center, top left corner, center right, center, center center left, bottom right corner, bottom center or bottom left corner.  
\item {\ttfamily obj.\-Set\-Gravity\-To\-Center\-Left ()} -\/ Specify if the input points define the center of the icon quad or one of top right corner, top center, top left corner, center right, center, center center left, bottom right corner, bottom center or bottom left corner.  
\item {\ttfamily obj.\-Set\-Gravity\-To\-Bottom\-Right ()} -\/ Specify if the input points define the center of the icon quad or one of top right corner, top center, top left corner, center right, center, center center left, bottom right corner, bottom center or bottom left corner.  
\item {\ttfamily obj.\-Set\-Gravity\-To\-Bottom\-Center ()} -\/ Specify if the input points define the center of the icon quad or one of top right corner, top center, top left corner, center right, center, center center left, bottom right corner, bottom center or bottom left corner.  
\item {\ttfamily obj.\-Set\-Gravity\-To\-Bottom\-Left ()} -\/ Specify if the input points define the center of the icon quad or one of top right corner, top center, top left corner, center right, center, center center left, bottom right corner, bottom center or bottom left corner.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkidfilter}{}\section{vtk\-Id\-Filter}\label{vtkgraphics_vtkidfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Id\-Filter is a filter to that generates scalars or field data using cell and point ids. That is, the point attribute data scalars or field data are generated from the point ids, and the cell attribute data scalars or field data are generated from the the cell ids.

Typically this filter is used with vtk\-Labeled\-Data\-Mapper (and possibly vtk\-Select\-Visible\-Points) to create labels for points and cells, or labels for the point or cell data scalar values.

To create an instance of class vtk\-Id\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkIdFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Id\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Id\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Id\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Id\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Point\-Ids (int )} -\/ Enable/disable the generation of point ids. Default is on.  
\item {\ttfamily int = obj.\-Get\-Point\-Ids ()} -\/ Enable/disable the generation of point ids. Default is on.  
\item {\ttfamily obj.\-Point\-Ids\-On ()} -\/ Enable/disable the generation of point ids. Default is on.  
\item {\ttfamily obj.\-Point\-Ids\-Off ()} -\/ Enable/disable the generation of point ids. Default is on.  
\item {\ttfamily obj.\-Set\-Cell\-Ids (int )} -\/ Enable/disable the generation of point ids. Default is on.  
\item {\ttfamily int = obj.\-Get\-Cell\-Ids ()} -\/ Enable/disable the generation of point ids. Default is on.  
\item {\ttfamily obj.\-Cell\-Ids\-On ()} -\/ Enable/disable the generation of point ids. Default is on.  
\item {\ttfamily obj.\-Cell\-Ids\-Off ()} -\/ Enable/disable the generation of point ids. Default is on.  
\item {\ttfamily obj.\-Set\-Field\-Data (int )} -\/ Set/\-Get the flag which controls whether to generate scalar data or field data. If this flag is off, scalar data is generated. Otherwise, field data is generated. Default is off.  
\item {\ttfamily int = obj.\-Get\-Field\-Data ()} -\/ Set/\-Get the flag which controls whether to generate scalar data or field data. If this flag is off, scalar data is generated. Otherwise, field data is generated. Default is off.  
\item {\ttfamily obj.\-Field\-Data\-On ()} -\/ Set/\-Get the flag which controls whether to generate scalar data or field data. If this flag is off, scalar data is generated. Otherwise, field data is generated. Default is off.  
\item {\ttfamily obj.\-Field\-Data\-Off ()} -\/ Set/\-Get the flag which controls whether to generate scalar data or field data. If this flag is off, scalar data is generated. Otherwise, field data is generated. Default is off.  
\item {\ttfamily obj.\-Set\-Ids\-Array\-Name (string )} -\/ Set/\-Get the name of the Ids array if generated. By default the Ids are named \char`\"{}vtk\-Id\-Filter\-\_\-\-Ids\char`\"{}, but this can be changed with this function.  
\item {\ttfamily string = obj.\-Get\-Ids\-Array\-Name ()} -\/ Set/\-Get the name of the Ids array if generated. By default the Ids are named \char`\"{}vtk\-Id\-Filter\-\_\-\-Ids\char`\"{}, but this can be changed with this function.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkimagedatageometryfilter}{}\section{vtk\-Image\-Data\-Geometry\-Filter}\label{vtkgraphics_vtkimagedatageometryfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Data\-Geometry\-Filter is a filter that extracts geometry from a structured points dataset. By specifying appropriate i-\/j-\/k indices (via the \char`\"{}\-Extent\char`\"{} instance variable), it is possible to extract a point, a line, a plane (i.\-e., image), or a \char`\"{}volume\char`\"{} from dataset. (Since the output is of type polydata, the volume is actually a (n x m x o) region of points.)

The extent specification is zero-\/offset. That is, the first k-\/plane in a 50x50x50 volume is given by (0,49, 0,49, 0,0).

To create an instance of class vtk\-Image\-Data\-Geometry\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageDataGeometryFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Data\-Geometry\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Data\-Geometry\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Data\-Geometry\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Data\-Geometry\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Extent (int extent\mbox{[}6\mbox{]})} -\/ Set / get the extent (imin,imax, jmin,jmax, kmin,kmax) indices.  
\item {\ttfamily obj.\-Set\-Extent (int i\-Min, int i\-Max, int j\-Min, int j\-Max, int k\-Min, int k\-Max)} -\/ Set / get the extent (imin,imax, jmin,jmax, kmin,kmax) indices.  
\item {\ttfamily obj.\-Set\-Threshold\-Cells (int )} -\/ Set Threshold\-Cells to true if you wish to skip any voxel/pixels which have scalar values less than the specified threshold. Currently this functionality is only implemented for 2\-D imagedata  
\item {\ttfamily int = obj.\-Get\-Threshold\-Cells ()} -\/ Set Threshold\-Cells to true if you wish to skip any voxel/pixels which have scalar values less than the specified threshold. Currently this functionality is only implemented for 2\-D imagedata  
\item {\ttfamily obj.\-Threshold\-Cells\-On ()} -\/ Set Threshold\-Cells to true if you wish to skip any voxel/pixels which have scalar values less than the specified threshold. Currently this functionality is only implemented for 2\-D imagedata  
\item {\ttfamily obj.\-Threshold\-Cells\-Off ()} -\/ Set Threshold\-Cells to true if you wish to skip any voxel/pixels which have scalar values less than the specified threshold. Currently this functionality is only implemented for 2\-D imagedata  
\item {\ttfamily obj.\-Set\-Threshold\-Value (double )} -\/ Set Threshold\-Value to the scalar value by which to threshhold cells when extracting geometry when Threshold\-Cells is true. Cells with scalar values greater than the threshold will be output.  
\item {\ttfamily double = obj.\-Get\-Threshold\-Value ()} -\/ Set Threshold\-Value to the scalar value by which to threshhold cells when extracting geometry when Threshold\-Cells is true. Cells with scalar values greater than the threshold will be output.  
\item {\ttfamily obj.\-Threshold\-Value\-On ()} -\/ Set Threshold\-Value to the scalar value by which to threshhold cells when extracting geometry when Threshold\-Cells is true. Cells with scalar values greater than the threshold will be output.  
\item {\ttfamily obj.\-Threshold\-Value\-Off ()} -\/ Set Threshold\-Value to the scalar value by which to threshhold cells when extracting geometry when Threshold\-Cells is true. Cells with scalar values greater than the threshold will be output.  
\item {\ttfamily obj.\-Set\-Output\-Triangles (int )} -\/ Set Output\-Triangles to true if you wish to generate triangles instead of quads when extracting cells from 2\-D imagedata Currently this functionality is only implemented for 2\-D imagedata  
\item {\ttfamily int = obj.\-Get\-Output\-Triangles ()} -\/ Set Output\-Triangles to true if you wish to generate triangles instead of quads when extracting cells from 2\-D imagedata Currently this functionality is only implemented for 2\-D imagedata  
\item {\ttfamily obj.\-Output\-Triangles\-On ()} -\/ Set Output\-Triangles to true if you wish to generate triangles instead of quads when extracting cells from 2\-D imagedata Currently this functionality is only implemented for 2\-D imagedata  
\item {\ttfamily obj.\-Output\-Triangles\-Off ()} -\/ Set Output\-Triangles to true if you wish to generate triangles instead of quads when extracting cells from 2\-D imagedata Currently this functionality is only implemented for 2\-D imagedata  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkimagemarchingcubes}{}\section{vtk\-Image\-Marching\-Cubes}\label{vtkgraphics_vtkimagemarchingcubes}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Marching\-Cubes is a filter that takes as input images (e.\-g., 3\-D image region) and generates on output one or more isosurfaces. One or more contour values must be specified to generate the isosurfaces. Alternatively, you can specify a min/max scalar range and the number of contours to generate a series of evenly spaced contour values. This filter can stream, so that the entire volume need not be loaded at once. Streaming is controlled using the instance variable Input\-Memory\-Limit, which has units K\-Bytes.

To create an instance of class vtk\-Image\-Marching\-Cubes, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageMarchingCubes
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Marching\-Cubes has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Marching\-Cubes class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Marching\-Cubes = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Marching\-Cubes = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Value (int i, double value)} -\/ Methods to set contour values  
\item {\ttfamily double = obj.\-Get\-Value (int i)} -\/ Methods to set contour values  
\item {\ttfamily obj.\-Get\-Values (double contour\-Values)} -\/ Methods to set contour values  
\item {\ttfamily obj.\-Set\-Number\-Of\-Contours (int number)} -\/ Methods to set contour values  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Contours ()} -\/ Methods to set contour values  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\mbox{[}2\mbox{]})} -\/ Methods to set contour values  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\-Start, double range\-End)} -\/ Methods to set contour values  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Because we delegate to vtk\-Contour\-Values \& refer to vtk\-Implicit\-Function  
\item {\ttfamily obj.\-Set\-Compute\-Scalars (int )} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily int = obj.\-Get\-Compute\-Scalars ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Compute\-Scalars\-On ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Compute\-Scalars\-Off ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Set\-Compute\-Normals (int )} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily int = obj.\-Get\-Compute\-Normals ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Normals\-On ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Normals\-Off ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Set\-Compute\-Gradients (int )} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily int = obj.\-Get\-Compute\-Gradients ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Gradients\-On ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Gradients\-Off ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily int = obj.\-Get\-Locator\-Point (int cell\-X, int cell\-Y, int edge)}  
\item {\ttfamily obj.\-Add\-Locator\-Point (int cell\-X, int cell\-Y, int edge, int pt\-Id)}  
\item {\ttfamily obj.\-Increment\-Locator\-Z ()}  
\item {\ttfamily obj.\-Set\-Input\-Memory\-Limit (int )} -\/ The Input\-Memory\-Limit determines the chunk size (the number of slices requested at each iteration). The units of this limit is Kilo\-Bytes. For now, only the Z axis is split.  
\item {\ttfamily int = obj.\-Get\-Input\-Memory\-Limit ()} -\/ The Input\-Memory\-Limit determines the chunk size (the number of slices requested at each iteration). The units of this limit is Kilo\-Bytes. For now, only the Z axis is split.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkimplicittexturecoords}{}\section{vtk\-Implicit\-Texture\-Coords}\label{vtkgraphics_vtkimplicittexturecoords}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Implicit\-Texture\-Coords is a filter to generate 1\-D, 2\-D, or 3\-D texture coordinates from one, two, or three implicit functions, respectively. In combinations with a vtk\-Boolean\-Texture map (or another texture map of your own creation), the texture coordinates can be used to highlight (via color or intensity) or cut (via transparency) dataset geometry without any complex geometric processing. (Note\-: the texture coordinates are referred to as r-\/s-\/t coordinates.)

The texture coordinates are automatically normalized to lie between (0,1). Thus, no matter what the implicit functions evaluate to, the resulting texture coordinates lie between (0,1), with the zero implicit function value mapped to the 0.\-5 texture coordinates value. Depending upon the maximum negative/positive implicit function values, the full (0,1) range may not be occupied (i.\-e., the positive/negative ranges are mapped using the same scale factor).

A boolean variable Invert\-Texture is available to flip the texture coordinates around 0.\-5 (value 1.\-0 becomes 0.\-0, 0.\-25-\/$>$0.\-75). This is equivalent to flipping the texture map (but a whole lot easier).

To create an instance of class vtk\-Implicit\-Texture\-Coords, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImplicitTextureCoords
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Implicit\-Texture\-Coords has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Implicit\-Texture\-Coords class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Implicit\-Texture\-Coords = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Implicit\-Texture\-Coords = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-R\-Function (vtk\-Implicit\-Function )} -\/ Specify an implicit function to compute the r texture coordinate.  
\item {\ttfamily vtk\-Implicit\-Function = obj.\-Get\-R\-Function ()} -\/ Specify an implicit function to compute the r texture coordinate.  
\item {\ttfamily obj.\-Set\-S\-Function (vtk\-Implicit\-Function )} -\/ Specify an implicit function to compute the s texture coordinate.  
\item {\ttfamily vtk\-Implicit\-Function = obj.\-Get\-S\-Function ()} -\/ Specify an implicit function to compute the s texture coordinate.  
\item {\ttfamily obj.\-Set\-T\-Function (vtk\-Implicit\-Function )} -\/ Specify an implicit function to compute the t texture coordinate.  
\item {\ttfamily vtk\-Implicit\-Function = obj.\-Get\-T\-Function ()} -\/ Specify an implicit function to compute the t texture coordinate.  
\item {\ttfamily obj.\-Set\-Flip\-Texture (int )} -\/ If enabled, this will flip the sense of inside and outside the implicit function (i.\-e., a rotation around the r-\/s-\/t=0.\-5 axis).  
\item {\ttfamily int = obj.\-Get\-Flip\-Texture ()} -\/ If enabled, this will flip the sense of inside and outside the implicit function (i.\-e., a rotation around the r-\/s-\/t=0.\-5 axis).  
\item {\ttfamily obj.\-Flip\-Texture\-On ()} -\/ If enabled, this will flip the sense of inside and outside the implicit function (i.\-e., a rotation around the r-\/s-\/t=0.\-5 axis).  
\item {\ttfamily obj.\-Flip\-Texture\-Off ()} -\/ If enabled, this will flip the sense of inside and outside the implicit function (i.\-e., a rotation around the r-\/s-\/t=0.\-5 axis).  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkinterpolatedatasetattributes}{}\section{vtk\-Interpolate\-Data\-Set\-Attributes}\label{vtkgraphics_vtkinterpolatedatasetattributes}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Interpolate\-Data\-Set\-Attributes is a filter that interpolates data set attribute values between input data sets. The input to the filter must be datasets of the same type, same number of cells, and same number of points. The output of the filter is a data set of the same type as the input dataset and whose attribute values have been interpolated at the parametric value specified.

The filter is used by specifying two or more input data sets (total of N), and a parametric value t (0 $<$= t $<$= N-\/1). The output will contain interpolated data set attributes common to all input data sets. (For example, if one input has scalars and vectors, and another has just scalars, then only scalars will be interpolated and output.)

To create an instance of class vtk\-Interpolate\-Data\-Set\-Attributes, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInterpolateDataSetAttributes
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Interpolate\-Data\-Set\-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\-Interpolate\-Data\-Set\-Attributes class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Interpolate\-Data\-Set\-Attributes = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Interpolate\-Data\-Set\-Attributes = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Data\-Set\-Collection = obj.\-Get\-Input\-List ()} -\/ Return the list of inputs to this filter.  
\item {\ttfamily obj.\-Set\-T (double )} -\/ Specify interpolation parameter t.  
\item {\ttfamily double = obj.\-Get\-T\-Min\-Value ()} -\/ Specify interpolation parameter t.  
\item {\ttfamily double = obj.\-Get\-T\-Max\-Value ()} -\/ Specify interpolation parameter t.  
\item {\ttfamily double = obj.\-Get\-T ()} -\/ Specify interpolation parameter t.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkinterpolatingsubdivisionfilter}{}\section{vtk\-Interpolating\-Subdivision\-Filter}\label{vtkgraphics_vtkinterpolatingsubdivisionfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Interpolating\-Subdivision\-Filter is an abstract class that defines the protocol for interpolating subdivision surface filters.

To create an instance of class vtk\-Interpolating\-Subdivision\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInterpolatingSubdivisionFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Interpolating\-Subdivision\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Interpolating\-Subdivision\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Interpolating\-Subdivision\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Interpolating\-Subdivision\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Number\-Of\-Subdivisions (int )} -\/ Set/get the number of subdivisions.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Subdivisions ()} -\/ Set/get the number of subdivisions.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkkdtreeselector}{}\section{vtk\-Kd\-Tree\-Selector}\label{vtkgraphics_vtkkdtreeselector}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
If Set\-Kd\-Tree is used, the filter ignores the input and selects based on that kd-\/tree. If Set\-Kd\-Tree is not used, the filter builds a kd-\/tree using the input point set and uses that tree for selection. The output is a vtk\-Selection containing the ids found in the kd-\/tree using the specified bounds.

To create an instance of class vtk\-Kd\-Tree\-Selector, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkKdTreeSelector
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Kd\-Tree\-Selector has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Kd\-Tree\-Selector class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Kd\-Tree\-Selector = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Kd\-Tree\-Selector = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Kd\-Tree (vtk\-Kd\-Tree tree)} -\/ The kd-\/tree to use to find selected ids. The kd-\/tree must be initialized with the desired set of points. When this is set, the optional input is ignored.  
\item {\ttfamily vtk\-Kd\-Tree = obj.\-Get\-Kd\-Tree ()} -\/ The kd-\/tree to use to find selected ids. The kd-\/tree must be initialized with the desired set of points. When this is set, the optional input is ignored.  
\item {\ttfamily obj.\-Set\-Selection\-Bounds (double , double , double , double , double , double )} -\/ The bounds of the form (xmin,xmax,ymin,ymax,zmin,zmax). To perform a search in 2\-D, use the bounds (xmin,xmax,ymin,ymax,V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E\-\_\-\-M\-I\-N,V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E\-\_\-\-M\-A\-X).  
\item {\ttfamily obj.\-Set\-Selection\-Bounds (double a\mbox{[}6\mbox{]})} -\/ The bounds of the form (xmin,xmax,ymin,ymax,zmin,zmax). To perform a search in 2\-D, use the bounds (xmin,xmax,ymin,ymax,V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E\-\_\-\-M\-I\-N,V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E\-\_\-\-M\-A\-X).  
\item {\ttfamily double = obj. Get\-Selection\-Bounds ()} -\/ The bounds of the form (xmin,xmax,ymin,ymax,zmin,zmax). To perform a search in 2\-D, use the bounds (xmin,xmax,ymin,ymax,V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E\-\_\-\-M\-I\-N,V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E\-\_\-\-M\-A\-X).  
\item {\ttfamily obj.\-Set\-Selection\-Field\-Name (string )} -\/ The field name to use when generating the selection. If set, creates a V\-A\-L\-U\-E\-S selection. If not set (or is set to N\-U\-L\-L), creates a I\-N\-D\-I\-C\-E\-S selection. By default this is not set.  
\item {\ttfamily string = obj.\-Get\-Selection\-Field\-Name ()} -\/ The field name to use when generating the selection. If set, creates a V\-A\-L\-U\-E\-S selection. If not set (or is set to N\-U\-L\-L), creates a I\-N\-D\-I\-C\-E\-S selection. By default this is not set.  
\item {\ttfamily obj.\-Set\-Selection\-Attribute (int )} -\/ The field attribute to use when generating the selection. If set, creates a P\-E\-D\-I\-G\-R\-E\-E\-I\-D\-S or G\-L\-O\-B\-A\-L\-I\-D\-S selection. If not set (or is set to -\/1), creates a I\-N\-D\-I\-C\-E\-S selection. By default this is not set. N\-O\-T\-E\-: This should be set a constant in vtk\-Data\-Set\-Attributes, not vtk\-Selection.  
\item {\ttfamily int = obj.\-Get\-Selection\-Attribute ()} -\/ The field attribute to use when generating the selection. If set, creates a P\-E\-D\-I\-G\-R\-E\-E\-I\-D\-S or G\-L\-O\-B\-A\-L\-I\-D\-S selection. If not set (or is set to -\/1), creates a I\-N\-D\-I\-C\-E\-S selection. By default this is not set. N\-O\-T\-E\-: This should be set a constant in vtk\-Data\-Set\-Attributes, not vtk\-Selection.  
\item {\ttfamily obj.\-Set\-Single\-Selection (bool )} -\/ Whether to only allow up to one value in the result. The item selected is closest to the center of the bounds, if there are any points within the selection threshold. Default is off.  
\item {\ttfamily bool = obj.\-Get\-Single\-Selection ()} -\/ Whether to only allow up to one value in the result. The item selected is closest to the center of the bounds, if there are any points within the selection threshold. Default is off.  
\item {\ttfamily obj.\-Single\-Selection\-On ()} -\/ Whether to only allow up to one value in the result. The item selected is closest to the center of the bounds, if there are any points within the selection threshold. Default is off.  
\item {\ttfamily obj.\-Single\-Selection\-Off ()} -\/ Whether to only allow up to one value in the result. The item selected is closest to the center of the bounds, if there are any points within the selection threshold. Default is off.  
\item {\ttfamily obj.\-Set\-Single\-Selection\-Threshold (double )} -\/ The threshold for the single selection. A single point is added to the selection if it is within this threshold from the bounds center. Default is 1.  
\item {\ttfamily double = obj.\-Get\-Single\-Selection\-Threshold ()} -\/ The threshold for the single selection. A single point is added to the selection if it is within this threshold from the bounds center. Default is 1.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtklevelidscalars}{}\section{vtk\-Level\-Id\-Scalars}\label{vtkgraphics_vtklevelidscalars}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Level\-Id\-Scalars is a filter that generates scalars using the level number for each level. Note that all datasets within a level get the same scalar. The new scalars array is named {\ttfamily Level\-Id\-Scalars}.

To create an instance of class vtk\-Level\-Id\-Scalars, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLevelIdScalars
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Level\-Id\-Scalars has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Level\-Id\-Scalars class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Level\-Id\-Scalars = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Level\-Id\-Scalars = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtklinearextrusionfilter}{}\section{vtk\-Linear\-Extrusion\-Filter}\label{vtkgraphics_vtklinearextrusionfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Linear\-Extrusion\-Filter is a modeling filter. It takes polygonal data as input and generates polygonal data on output. The input dataset is swept according to some extrusion function and creates new polygonal primitives. These primitives form a \char`\"{}skirt\char`\"{} or swept surface. For example, sweeping a line results in a quadrilateral, and sweeping a triangle creates a \char`\"{}wedge\char`\"{}.

There are a number of control parameters for this filter. You can control whether the sweep of a 2\-D object (i.\-e., polygon or triangle strip) is capped with the generating geometry via the \char`\"{}\-Capping\char`\"{} ivar. Also, you can extrude in the direction of a user specified vector, towards a point, or in the direction of vertex normals (normals must be provided -\/ use vtk\-Poly\-Data\-Normals if necessary). The amount of extrusion is controlled by the \char`\"{}\-Scale\-Factor\char`\"{} instance variable.

The skirt is generated by locating certain topological features. Free edges (edges of polygons or triangle strips only used by one polygon or triangle strips) generate surfaces. This is true also of lines or polylines. Vertices generate lines.

This filter can be used to create 3\-D fonts, 3\-D irregular bar charts, or to model 2 1/2\-D objects like punched plates. It also can be used to create solid objects from 2\-D polygonal meshes.

To create an instance of class vtk\-Linear\-Extrusion\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLinearExtrusionFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Linear\-Extrusion\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Linear\-Extrusion\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Linear\-Extrusion\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Linear\-Extrusion\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Extrusion\-Type (int )} -\/ Set/\-Get the type of extrusion.  
\item {\ttfamily int = obj.\-Get\-Extrusion\-Type\-Min\-Value ()} -\/ Set/\-Get the type of extrusion.  
\item {\ttfamily int = obj.\-Get\-Extrusion\-Type\-Max\-Value ()} -\/ Set/\-Get the type of extrusion.  
\item {\ttfamily int = obj.\-Get\-Extrusion\-Type ()} -\/ Set/\-Get the type of extrusion.  
\item {\ttfamily obj.\-Set\-Extrusion\-Type\-To\-Vector\-Extrusion ()} -\/ Set/\-Get the type of extrusion.  
\item {\ttfamily obj.\-Set\-Extrusion\-Type\-To\-Normal\-Extrusion ()} -\/ Set/\-Get the type of extrusion.  
\item {\ttfamily obj.\-Set\-Extrusion\-Type\-To\-Point\-Extrusion ()} -\/ Set/\-Get the type of extrusion.  
\item {\ttfamily obj.\-Set\-Capping (int )} -\/ Turn on/off the capping of the skirt.  
\item {\ttfamily int = obj.\-Get\-Capping ()} -\/ Turn on/off the capping of the skirt.  
\item {\ttfamily obj.\-Capping\-On ()} -\/ Turn on/off the capping of the skirt.  
\item {\ttfamily obj.\-Capping\-Off ()} -\/ Turn on/off the capping of the skirt.  
\item {\ttfamily obj.\-Set\-Scale\-Factor (double )} -\/ Set/\-Get extrusion scale factor,  
\item {\ttfamily double = obj.\-Get\-Scale\-Factor ()} -\/ Set/\-Get extrusion scale factor,  
\item {\ttfamily obj.\-Set\-Vector (double , double , double )} -\/ Set/\-Get extrusion vector. Only needs to be set if Vector\-Extrusion is turned on.  
\item {\ttfamily obj.\-Set\-Vector (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get extrusion vector. Only needs to be set if Vector\-Extrusion is turned on.  
\item {\ttfamily double = obj. Get\-Vector ()} -\/ Set/\-Get extrusion vector. Only needs to be set if Vector\-Extrusion is turned on.  
\item {\ttfamily obj.\-Set\-Extrusion\-Point (double , double , double )} -\/ Set/\-Get extrusion point. Only needs to be set if Point\-Extrusion is turned on. This is the point towards which extrusion occurs.  
\item {\ttfamily obj.\-Set\-Extrusion\-Point (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get extrusion point. Only needs to be set if Point\-Extrusion is turned on. This is the point towards which extrusion occurs.  
\item {\ttfamily double = obj. Get\-Extrusion\-Point ()} -\/ Set/\-Get extrusion point. Only needs to be set if Point\-Extrusion is turned on. This is the point towards which extrusion occurs.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtklinearsubdivisionfilter}{}\section{vtk\-Linear\-Subdivision\-Filter}\label{vtkgraphics_vtklinearsubdivisionfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Linear\-Subdivision\-Filter is a filter that generates output by subdividing its input polydata. Each subdivision iteration create 4 new triangles for each triangle in the polydata.

To create an instance of class vtk\-Linear\-Subdivision\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLinearSubdivisionFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Linear\-Subdivision\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Linear\-Subdivision\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Construct object with Number\-Of\-Subdivisions set to 1.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Construct object with Number\-Of\-Subdivisions set to 1.  
\item {\ttfamily vtk\-Linear\-Subdivision\-Filter = obj.\-New\-Instance ()} -\/ Construct object with Number\-Of\-Subdivisions set to 1.  
\item {\ttfamily vtk\-Linear\-Subdivision\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Construct object with Number\-Of\-Subdivisions set to 1.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtklinesource}{}\section{vtk\-Line\-Source}\label{vtkgraphics_vtklinesource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Line\-Source is a source object that creates a polyline defined by two endpoints. The number of segments composing the polyline is controlled by setting the object resolution.

To create an instance of class vtk\-Line\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLineSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Line\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Line\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Line\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Line\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Point1 (double , double , double )} -\/ Set position of first end point.  
\item {\ttfamily obj.\-Set\-Point1 (double a\mbox{[}3\mbox{]})} -\/ Set position of first end point.  
\item {\ttfamily double = obj. Get\-Point1 ()} -\/ Set position of first end point.  
\item {\ttfamily obj.\-Set\-Point2 (double , double , double )} -\/ Set position of other end point.  
\item {\ttfamily obj.\-Set\-Point2 (double a\mbox{[}3\mbox{]})} -\/ Set position of other end point.  
\item {\ttfamily double = obj. Get\-Point2 ()} -\/ Set position of other end point.  
\item {\ttfamily obj.\-Set\-Resolution (int )} -\/ Divide line into resolution number of pieces.  
\item {\ttfamily int = obj.\-Get\-Resolution\-Min\-Value ()} -\/ Divide line into resolution number of pieces.  
\item {\ttfamily int = obj.\-Get\-Resolution\-Max\-Value ()} -\/ Divide line into resolution number of pieces.  
\item {\ttfamily int = obj.\-Get\-Resolution ()} -\/ Divide line into resolution number of pieces.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtklinkedgels}{}\section{vtk\-Link\-Edgels}\label{vtkgraphics_vtklinkedgels}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Link\-Edgels links edgels into digital curves which are then stored as polylines. The algorithm works one pixel at a time only looking at its immediate neighbors. There is a Gradient\-Threshold that can be set that eliminates any pixels with a smaller gradient value. This can be used as the lower threshold of a two value edgel thresholding.

For the remaining edgels, links are first tried for the four connected neighbors. A successful neighbor will satisfy three tests. First both edgels must be above the gradient threshold. Second, the difference between the orientation between the two edgels (Alpha) and each edgels orientation (Phi) must be less than Link\-Threshold. Third, the difference between the two edgels Phi values must be less than Phi\-Threshold. The most successful link is selected. The measure is simply the sum of the three angle differences (actually stored as the sum of the cosines). If none of the four connect neighbors succeeds, then the eight connect neighbors are examined using the same method.

This filter requires gradient information so you will need to use a vtk\-Image\-Gradient at some point prior to this filter. Typically a vtk\-Non\-Maximum\-Suppression filter is also used. vtk\-Threshold\-Edgels can be used to complete the two value edgel thresholding as used in a Canny edge detector. The vtk\-Subpixel\-Position\-Edgels filter can also be used after this filter to adjust the edgel locations.

To create an instance of class vtk\-Link\-Edgels, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLinkEdgels
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Link\-Edgels has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Link\-Edgels class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Link\-Edgels = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Link\-Edgels = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Link\-Threshold (double )} -\/ Set/\-Get the threshold for Phi vs. Alpha link thresholding.  
\item {\ttfamily double = obj.\-Get\-Link\-Threshold ()} -\/ Set/\-Get the threshold for Phi vs. Alpha link thresholding.  
\item {\ttfamily obj.\-Set\-Phi\-Threshold (double )} -\/ Set/get the threshold for Phi vs. Phi link thresholding.  
\item {\ttfamily double = obj.\-Get\-Phi\-Threshold ()} -\/ Set/get the threshold for Phi vs. Phi link thresholding.  
\item {\ttfamily obj.\-Set\-Gradient\-Threshold (double )} -\/ Set/\-Get the threshold for image gradient thresholding.  
\item {\ttfamily double = obj.\-Get\-Gradient\-Threshold ()} -\/ Set/\-Get the threshold for image gradient thresholding.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkloopsubdivisionfilter}{}\section{vtk\-Loop\-Subdivision\-Filter}\label{vtkgraphics_vtkloopsubdivisionfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Loop\-Subdivision\-Filter is an approximating subdivision scheme that creates four new triangles for each triangle in the mesh. The user can specify the Number\-Of\-Subdivisions. Loop's subdivision scheme is described in\-: Loop, C., \char`\"{}\-Smooth Subdivision surfaces based on
 triangles,\char`\"{}, Masters Thesis, University of Utah, August 1987. For a nice summary of the technique see, Hoppe, H., et. al, "Piecewise Smooth Surface Reconstruction,\-:, Proceedings of Siggraph 94 (Orlando, Florida, July 24-\/29, 1994). In C\-Omputer Graphics Proceedings, Annual C\-Onference Series, 1994, A\-C\-M S\-I\-G\-G\-R\-A\-P\-H, pp. 295-\/302. 

The filter only operates on triangles. Users should use the vtk\-Triangle\-Filter to triangulate meshes that contain polygons or triangle strips. 

The filter approximates point data using the same scheme. New triangles create at a subdivision step will have the cell data of their parent cell.

To create an instance of class vtk\-Loop\-Subdivision\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLoopSubdivisionFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Loop\-Subdivision\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Loop\-Subdivision\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Construct object with Number\-Of\-Subdivisions set to 1.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Construct object with Number\-Of\-Subdivisions set to 1.  
\item {\ttfamily vtk\-Loop\-Subdivision\-Filter = obj.\-New\-Instance ()} -\/ Construct object with Number\-Of\-Subdivisions set to 1.  
\item {\ttfamily vtk\-Loop\-Subdivision\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Construct object with Number\-Of\-Subdivisions set to 1.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkmarchingcontourfilter}{}\section{vtk\-Marching\-Contour\-Filter}\label{vtkgraphics_vtkmarchingcontourfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Marching\-Contour\-Filter is a filter that takes as input any dataset and generates on output isosurfaces and/or isolines. The exact form of the output depends upon the dimensionality of the input data. Data consisting of 3\-D cells will generate isosurfaces, data consisting of 2\-D cells will generate isolines, and data with 1\-D or 0\-D cells will generate isopoints. Combinations of output type are possible if the input dimension is mixed.

This filter will identify special dataset types (e.\-g., structured points) and use the appropriate specialized filter to process the data. For examples, if the input dataset type is a volume, this filter will create an internal vtk\-Marching\-Cubes instance and use it. This gives much better performance.

To use this filter you must specify one or more contour values. You can either use the method Set\-Value() to specify each contour value, or use Generate\-Values() to generate a series of evenly spaced contours. It is also possible to accelerate the operation of this filter (at the cost of extra memory) by using a vtk\-Scalar\-Tree. A scalar tree is used to quickly locate cells that contain a contour surface. This is especially effective if multiple contours are being extracted. If you want to use a scalar tree, invoke the method Use\-Scalar\-Tree\-On().

To create an instance of class vtk\-Marching\-Contour\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMarchingContourFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Marching\-Contour\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Marching\-Contour\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Marching\-Contour\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Marching\-Contour\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Value (int i, double value)} -\/ Methods to set / get contour values.  
\item {\ttfamily double = obj.\-Get\-Value (int i)} -\/ Methods to set / get contour values.  
\item {\ttfamily obj.\-Get\-Values (double contour\-Values)} -\/ Methods to set / get contour values.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Contours (int number)} -\/ Methods to set / get contour values.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Contours ()} -\/ Methods to set / get contour values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\mbox{[}2\mbox{]})} -\/ Methods to set / get contour values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\-Start, double range\-End)} -\/ Methods to set / get contour values.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Modified Get\-M\-Time Because we delegate to vtk\-Contour\-Values  
\item {\ttfamily obj.\-Set\-Compute\-Normals (int )} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily int = obj.\-Get\-Compute\-Normals ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Normals\-On ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Normals\-Off ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Set\-Compute\-Gradients (int )} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily int = obj.\-Get\-Compute\-Gradients ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Gradients\-On ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Gradients\-Off ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Set\-Compute\-Scalars (int )} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily int = obj.\-Get\-Compute\-Scalars ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Compute\-Scalars\-On ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Compute\-Scalars\-Off ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Set\-Use\-Scalar\-Tree (int )} -\/ Enable the use of a scalar tree to accelerate contour extraction.  
\item {\ttfamily int = obj.\-Get\-Use\-Scalar\-Tree ()} -\/ Enable the use of a scalar tree to accelerate contour extraction.  
\item {\ttfamily obj.\-Use\-Scalar\-Tree\-On ()} -\/ Enable the use of a scalar tree to accelerate contour extraction.  
\item {\ttfamily obj.\-Use\-Scalar\-Tree\-Off ()} -\/ Enable the use of a scalar tree to accelerate contour extraction.  
\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. The locator is used to merge coincident points.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkmarchingcubes}{}\section{vtk\-Marching\-Cubes}\label{vtkgraphics_vtkmarchingcubes}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Marching\-Cubes is a filter that takes as input a volume (e.\-g., 3\-D structured point set) and generates on output one or more isosurfaces. One or more contour values must be specified to generate the isosurfaces. Alternatively, you can specify a min/max scalar range and the number of contours to generate a series of evenly spaced contour values.

To create an instance of class vtk\-Marching\-Cubes, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMarchingCubes
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Marching\-Cubes has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Marching\-Cubes class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Marching\-Cubes = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Marching\-Cubes = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Value (int i, double value)}  
\item {\ttfamily double = obj.\-Get\-Value (int i)}  
\item {\ttfamily obj.\-Get\-Values (double contour\-Values)}  
\item {\ttfamily obj.\-Set\-Number\-Of\-Contours (int number)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Contours ()}  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\mbox{[}2\mbox{]})}  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\-Start, double range\-End)}  
\item {\ttfamily long = obj.\-Get\-M\-Time ()}  
\item {\ttfamily obj.\-Set\-Compute\-Normals (int )} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily int = obj.\-Get\-Compute\-Normals ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Normals\-On ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Normals\-Off ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Set\-Compute\-Gradients (int )} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily int = obj.\-Get\-Compute\-Gradients ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Gradients\-On ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Gradients\-Off ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Set\-Compute\-Scalars (int )} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily int = obj.\-Get\-Compute\-Scalars ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Compute\-Scalars\-On ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Compute\-Scalars\-Off ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Set\-Locator (vtk\-Incremental\-Point\-Locator locator)} -\/ Overide the default locator. Useful for changing the number of bins for performance or specifying a more aggressive locator.  
\item {\ttfamily vtk\-Incremental\-Point\-Locator = obj.\-Get\-Locator ()} -\/ Overide the default locator. Useful for changing the number of bins for performance or specifying a more aggressive locator.  
\item {\ttfamily obj.\-Create\-Default\-Locator ()} -\/ Create default locator. Used to create one when none is specified. The locator is used to merge coincident points.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkmarchingsquares}{}\section{vtk\-Marching\-Squares}\label{vtkgraphics_vtkmarchingsquares}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Marching\-Squares is a filter that takes as input a structured points set and generates on output one or more isolines. One or more contour values must be specified to generate the isolines. Alternatively, you can specify a min/max scalar range and the number of contours to generate a series of evenly spaced contour values.

To generate contour lines the input data must be of topological dimension 2 (i.\-e., an image). If not, you can use the Image\-Range ivar to select an image plane from an input volume. This avoids having to extract a plane first (using vtk\-Extract\-Sub\-Volume). The filter deals with this by first trying to use the input data directly, and if not a 2\-D image, then uses the Image\-Range ivar to reduce it to an image.

To create an instance of class vtk\-Marching\-Squares, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMarchingSquares
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Marching\-Squares has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Marching\-Squares class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Marching\-Squares = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Marching\-Squares = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Image\-Range (int \mbox{[}6\mbox{]})} -\/ Set/\-Get the i-\/j-\/k index range which define a plane on which to generate contour lines. Using this ivar it is possible to input a 3\-D volume directly and then generate contour lines on one of the i-\/j-\/k planes, or a portion of a plane.  
\item {\ttfamily int = obj. Get\-Image\-Range ()} -\/ Set/\-Get the i-\/j-\/k index range which define a plane on which to generate contour lines. Using this ivar it is possible to input a 3\-D volume directly and then generate contour lines on one of the i-\/j-\/k planes, or a portion of a plane.  
\item {\ttfamily obj.\-Set\-Image\-Range (int imin, int imax, int jmin, int jmax, int kmin, int kmax)} -\/ Set/\-Get the i-\/j-\/k index range which define a plane on which to generate contour lines. Using this ivar it is possible to input a 3\-D volume directly and then generate contour lines on one of the i-\/j-\/k planes, or a portion of a plane.  
\item {\ttfamily obj.\-Set\-Value (int i, double value)} -\/ Methods to set contour values  
\item {\ttfamily double = obj.\-Get\-Value (int i)} -\/ Methods to set contour values  
\item {\ttfamily obj.\-Get\-Values (double contour\-Values)} -\/ Methods to set contour values  
\item {\ttfamily obj.\-Set\-Number\-Of\-Contours (int number)} -\/ Methods to set contour values  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Contours ()} -\/ Methods to set contour values  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\mbox{[}2\mbox{]})} -\/ Methods to set contour values  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\-Start, double range\-End)} -\/ Methods to set contour values  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Because we delegate to vtk\-Contour\-Values  
\item {\ttfamily obj.\-Set\-Locator (vtk\-Incremental\-Point\-Locator locator)}  
\item {\ttfamily vtk\-Incremental\-Point\-Locator = obj.\-Get\-Locator ()}  
\item {\ttfamily obj.\-Create\-Default\-Locator ()} -\/ Create default locator. Used to create one when none is specified. The locator is used to merge coincident points.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkmaskfields}{}\section{vtk\-Mask\-Fields}\label{vtkgraphics_vtkmaskfields}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Mask\-Fields is used to mark which fields in the input dataset get copied to the output. The output will contain only those fields marked as on by the filter.

To create an instance of class vtk\-Mask\-Fields, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMaskFields
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Mask\-Fields has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Mask\-Fields class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Mask\-Fields = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Mask\-Fields = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Copy\-Field\-On (int field\-Location, string name)} -\/ Turn on/off the copying of the field or specified by name. During the copying/passing, the following rules are followed for each array\-:
\begin{DoxyEnumerate}
\item If the copy flag for an array is set (on or off), it is applied This overrides rule 2.
\item If Copy\-All\-On is set, copy the array. If Copy\-All\-Off is set, do not copy the array A field name and a location must be specified. For example\-: \begin{DoxyVerb} maskFields->CopyFieldOff(vtkMaskFields::CELL_DATA, "foo");\end{DoxyVerb}
 causes the field \char`\"{}foo\char`\"{} on the input cell data to not get copied to the output.  
\end{DoxyEnumerate}
\item {\ttfamily obj.\-Copy\-Field\-Off (int field\-Location, string name)} -\/ Turn on/off the copying of the attribute or specified by vtk\-Data\-Set\-Attributes\-:Attribute\-Types. During the copying/passing, the following rules are followed for each array\-:
\begin{DoxyEnumerate}
\item If the copy flag for an array is set (on or off), it is applied This overrides rule 2.
\item If Copy\-All\-On is set, copy the array. If Copy\-All\-Off is set, do not copy the array An attribute type and a location must be specified. For example\-: \begin{DoxyVerb} maskFields->CopyAttributeOff(vtkMaskFields::POINT_DATA, vtkDataSetAttributes::SCALARS);\end{DoxyVerb}
 causes the scalars on the input point data to not get copied to the output.  
\end{DoxyEnumerate}
\item {\ttfamily obj.\-Copy\-Attribute\-On (int attribute\-Location, int attribute\-Type)} -\/ Turn on/off the copying of the attribute or specified by vtk\-Data\-Set\-Attributes\-:Attribute\-Types. During the copying/passing, the following rules are followed for each array\-:
\begin{DoxyEnumerate}
\item If the copy flag for an array is set (on or off), it is applied This overrides rule 2.
\item If Copy\-All\-On is set, copy the array. If Copy\-All\-Off is set, do not copy the array An attribute type and a location must be specified. For example\-: \begin{DoxyVerb} maskFields->CopyAttributeOff(vtkMaskFields::POINT_DATA, vtkDataSetAttributes::SCALARS);\end{DoxyVerb}
 causes the scalars on the input point data to not get copied to the output.  
\end{DoxyEnumerate}
\item {\ttfamily obj.\-Copy\-Attribute\-Off (int attribute\-Location, int attribute\-Type)} -\/ Convenience methods which operate on all field data or attribute data. More specific than Copy\-All\-On or Copy\-All\-Off  
\item {\ttfamily obj.\-Copy\-Fields\-Off ()} -\/ Convenience methods which operate on all field data or attribute data. More specific than Copy\-All\-On or Copy\-All\-Off  
\item {\ttfamily obj.\-Copy\-Attributes\-Off ()}  
\item {\ttfamily obj.\-Copy\-Fields\-On ()}  
\item {\ttfamily obj.\-Copy\-Attributes\-On ()} -\/ Helper methods used by other language bindings. Allows the caller to specify arguments as strings instead of enums.  
\item {\ttfamily obj.\-Copy\-Attribute\-On (string attribute\-Loc, string attribute\-Type)} -\/ Helper methods used by other language bindings. Allows the caller to specify arguments as strings instead of enums.  
\item {\ttfamily obj.\-Copy\-Attribute\-Off (string attribute\-Loc, string attribute\-Type)} -\/ Helper methods used by other language bindings. Allows the caller to specify arguments as strings instead of enums.  
\item {\ttfamily obj.\-Copy\-Field\-On (string field\-Loc, string name)} -\/ Helper methods used by other language bindings. Allows the caller to specify arguments as strings instead of enums.  
\item {\ttfamily obj.\-Copy\-Field\-Off (string field\-Loc, string name)} -\/ Helper methods used by other language bindings. Allows the caller to specify arguments as strings instead of enums.  
\item {\ttfamily obj.\-Copy\-All\-On ()} -\/ Turn on copying of all data. During the copying/passing, the following rules are followed for each array\-:
\begin{DoxyEnumerate}
\item If the copy flag for an array is set (on or off), it is applied This overrides rule 2.
\item If Copy\-All\-On is set, copy the array. If Copy\-All\-Off is set, do not copy the array  
\end{DoxyEnumerate}
\item {\ttfamily obj.\-Copy\-All\-Off ()} -\/ Turn off copying of all data. During the copying/passing, the following rules are followed for each array\-:
\begin{DoxyEnumerate}
\item If the copy flag for an array is set (on or off), it is applied This overrides rule 2.
\item If Copy\-All\-On is set, copy the array. If Copy\-All\-Off is set, do not copy the array  
\end{DoxyEnumerate}
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkmaskpoints}{}\section{vtk\-Mask\-Points}\label{vtkgraphics_vtkmaskpoints}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Mask\-Points is a filter that passes through points and point attributes from input dataset. (Other geometry is not passed through.) It is possible to mask every nth point, and to specify an initial offset to begin masking from. A special random mode feature enables random selection of points. The filter can also generate vertices (topological primitives) as well as points. This is useful because vertices are rendered while points are not.

To create an instance of class vtk\-Mask\-Points, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMaskPoints
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Mask\-Points has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Mask\-Points class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Mask\-Points = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Mask\-Points = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-On\-Ratio (int )} -\/ Turn on every nth point.  
\item {\ttfamily int = obj.\-Get\-On\-Ratio\-Min\-Value ()} -\/ Turn on every nth point.  
\item {\ttfamily int = obj.\-Get\-On\-Ratio\-Max\-Value ()} -\/ Turn on every nth point.  
\item {\ttfamily int = obj.\-Get\-On\-Ratio ()} -\/ Turn on every nth point.  
\item {\ttfamily obj.\-Set\-Maximum\-Number\-Of\-Points (vtk\-Id\-Type )} -\/ Limit the number of points that can be passed through.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Maximum\-Number\-Of\-Points\-Min\-Value ()} -\/ Limit the number of points that can be passed through.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Maximum\-Number\-Of\-Points\-Max\-Value ()} -\/ Limit the number of points that can be passed through.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Maximum\-Number\-Of\-Points ()} -\/ Limit the number of points that can be passed through.  
\item {\ttfamily obj.\-Set\-Offset (vtk\-Id\-Type )} -\/ Start with this point.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Offset\-Min\-Value ()} -\/ Start with this point.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Offset\-Max\-Value ()} -\/ Start with this point.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Offset ()} -\/ Start with this point.  
\item {\ttfamily obj.\-Set\-Random\-Mode (int )} -\/ Special flag causes randomization of point selection. If this mode is on, statistically every nth point (i.\-e., On\-Ratio) will be displayed.  
\item {\ttfamily int = obj.\-Get\-Random\-Mode ()} -\/ Special flag causes randomization of point selection. If this mode is on, statistically every nth point (i.\-e., On\-Ratio) will be displayed.  
\item {\ttfamily obj.\-Random\-Mode\-On ()} -\/ Special flag causes randomization of point selection. If this mode is on, statistically every nth point (i.\-e., On\-Ratio) will be displayed.  
\item {\ttfamily obj.\-Random\-Mode\-Off ()} -\/ Special flag causes randomization of point selection. If this mode is on, statistically every nth point (i.\-e., On\-Ratio) will be displayed.  
\item {\ttfamily obj.\-Set\-Generate\-Vertices (int )} -\/ Generate output polydata vertices as well as points. A useful convenience method because vertices are drawn (they are topology) while points are not (they are geometry). By default this method is off.  
\item {\ttfamily int = obj.\-Get\-Generate\-Vertices ()} -\/ Generate output polydata vertices as well as points. A useful convenience method because vertices are drawn (they are topology) while points are not (they are geometry). By default this method is off.  
\item {\ttfamily obj.\-Generate\-Vertices\-On ()} -\/ Generate output polydata vertices as well as points. A useful convenience method because vertices are drawn (they are topology) while points are not (they are geometry). By default this method is off.  
\item {\ttfamily obj.\-Generate\-Vertices\-Off ()} -\/ Generate output polydata vertices as well as points. A useful convenience method because vertices are drawn (they are topology) while points are not (they are geometry). By default this method is off.  
\item {\ttfamily obj.\-Set\-Single\-Vertex\-Per\-Cell (int )} -\/ When vertex generation is enabled, by default vertices are produced as multi-\/vertex cells (more than one per cell), if you wish to have a single vertex per cell, enable this flag.  
\item {\ttfamily int = obj.\-Get\-Single\-Vertex\-Per\-Cell ()} -\/ When vertex generation is enabled, by default vertices are produced as multi-\/vertex cells (more than one per cell), if you wish to have a single vertex per cell, enable this flag.  
\item {\ttfamily obj.\-Single\-Vertex\-Per\-Cell\-On ()} -\/ When vertex generation is enabled, by default vertices are produced as multi-\/vertex cells (more than one per cell), if you wish to have a single vertex per cell, enable this flag.  
\item {\ttfamily obj.\-Single\-Vertex\-Per\-Cell\-Off ()} -\/ When vertex generation is enabled, by default vertices are produced as multi-\/vertex cells (more than one per cell), if you wish to have a single vertex per cell, enable this flag.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkmaskpolydata}{}\section{vtk\-Mask\-Poly\-Data}\label{vtkgraphics_vtkmaskpolydata}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Mask\-Poly\-Data is a filter that sub-\/samples the cells of input polygonal data. The user specifies every nth item, with an initial offset to begin sampling.

To create an instance of class vtk\-Mask\-Poly\-Data, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMaskPolyData
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Mask\-Poly\-Data has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Mask\-Poly\-Data class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Mask\-Poly\-Data = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Mask\-Poly\-Data = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-On\-Ratio (int )} -\/ Turn on every nth entity (cell).  
\item {\ttfamily int = obj.\-Get\-On\-Ratio\-Min\-Value ()} -\/ Turn on every nth entity (cell).  
\item {\ttfamily int = obj.\-Get\-On\-Ratio\-Max\-Value ()} -\/ Turn on every nth entity (cell).  
\item {\ttfamily int = obj.\-Get\-On\-Ratio ()} -\/ Turn on every nth entity (cell).  
\item {\ttfamily obj.\-Set\-Offset (vtk\-Id\-Type )} -\/ Start with this entity (cell).  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Offset\-Min\-Value ()} -\/ Start with this entity (cell).  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Offset\-Max\-Value ()} -\/ Start with this entity (cell).  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Offset ()} -\/ Start with this entity (cell).  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkmassproperties}{}\section{vtk\-Mass\-Properties}\label{vtkgraphics_vtkmassproperties}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Mass\-Properties estimates the volume, the surface area, and the normalized shape index of a triangle mesh. The algorithm implemented here is based on the discrete form of the divergence theorem. The general assumption here is that the model is of closed surface. For more details see the following reference (Alyassin A.\-M. et al, \char`\"{}\-Evaluation of new algorithms for the
 interactive measurement of surface area and volume\char`\"{}, Med Phys 21(6) 1994.).

To create an instance of class vtk\-Mass\-Properties, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMassProperties
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Mass\-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\-Mass\-Properties class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Mass\-Properties = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Mass\-Properties = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily double = obj.\-Get\-Volume ()} -\/ Compute and return the projected volume. Typically you should compare this volume to the value returned by Get\-Volume if you get an error (Get\-Volume()-\/\-Get\-Volume\-Projected())$\ast$10000 that is greater than Get\-Volume() this should identify a problem\-: Either the polydata is not closed Or the polydata contains triangle that are flipped  
\item {\ttfamily double = obj.\-Get\-Volume\-Projected ()} -\/ Compute and return the volume projected on to each axis aligned plane.  
\item {\ttfamily double = obj.\-Get\-Volume\-X ()} -\/ Compute and return the volume projected on to each axis aligned plane.  
\item {\ttfamily double = obj.\-Get\-Volume\-Y ()} -\/ Compute and return the volume projected on to each axis aligned plane.  
\item {\ttfamily double = obj.\-Get\-Volume\-Z ()} -\/ Compute and return the weighting factors for the maximum unit normal component (M\-U\-N\-C).  
\item {\ttfamily double = obj.\-Get\-Kx ()} -\/ Compute and return the weighting factors for the maximum unit normal component (M\-U\-N\-C).  
\item {\ttfamily double = obj.\-Get\-Ky ()} -\/ Compute and return the weighting factors for the maximum unit normal component (M\-U\-N\-C).  
\item {\ttfamily double = obj.\-Get\-Kz ()} -\/ Compute and return the area.  
\item {\ttfamily double = obj.\-Get\-Surface\-Area ()} -\/ Compute and return the min cell area.  
\item {\ttfamily double = obj.\-Get\-Min\-Cell\-Area ()} -\/ Compute and return the max cell area.  
\item {\ttfamily double = obj.\-Get\-Max\-Cell\-Area ()} -\/ Compute and return the normalized shape index. This characterizes the deviation of the shape of an object from a sphere. A sphere's N\-S\-I is one. This number is always $>$= 1.\-0.  
\item {\ttfamily double = obj.\-Get\-Normalized\-Shape\-Index ()}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkmergecells}{}\section{vtk\-Merge\-Cells}\label{vtkgraphics_vtkmergecells}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Designed to work with distributed vtk\-Data\-Sets, this class will take vtk\-Data\-Sets and merge them back into a single vtk\-Unstructured\-Grid.

The vtk\-Points object of the unstructured grid will have data type V\-T\-K\-\_\-\-F\-L\-O\-A\-T, regardless of the data type of the points of the input vtk\-Data\-Sets. If this is a problem, someone must let me know.

It is assumed the different Data\-Sets have the same field arrays. If the name of a global point I\-D array is provided, this class will refrain from including duplicate points in the merged Ugrid. This class differs from vtk\-Append\-Filter in these ways\-: (1) it uses less memory than that class (which uses memory equal to twice the size of the final Ugrid) but requires that you know the size of the final Ugrid in advance (2) this class assumes the individual Data\-Sets have the same field arrays, while vtk\-Append\-Filter intersects the field arrays (3) this class knows duplicate points may be appearing in the Data\-Sets and can filter those out, (4) this class is not a filter.

To create an instance of class vtk\-Merge\-Cells, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMergeCells
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Merge\-Cells has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Merge\-Cells class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Merge\-Cells = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Merge\-Cells = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Unstructured\-Grid (vtk\-Unstructured\-Grid )}  
\item {\ttfamily vtk\-Unstructured\-Grid = obj.\-Get\-Unstructured\-Grid ()}  
\item {\ttfamily obj.\-Set\-Total\-Number\-Of\-Cells (vtk\-Id\-Type )}  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Total\-Number\-Of\-Cells ()}  
\item {\ttfamily obj.\-Set\-Total\-Number\-Of\-Points (vtk\-Id\-Type )}  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Total\-Number\-Of\-Points ()}  
\item {\ttfamily obj.\-Set\-Use\-Global\-Ids (int )}  
\item {\ttfamily int = obj.\-Get\-Use\-Global\-Ids ()}  
\item {\ttfamily obj.\-Set\-Point\-Merge\-Tolerance (float )}  
\item {\ttfamily float = obj.\-Get\-Point\-Merge\-Tolerance\-Min\-Value ()}  
\item {\ttfamily float = obj.\-Get\-Point\-Merge\-Tolerance\-Max\-Value ()}  
\item {\ttfamily float = obj.\-Get\-Point\-Merge\-Tolerance ()}  
\item {\ttfamily obj.\-Set\-Use\-Global\-Cell\-Ids (int )}  
\item {\ttfamily int = obj.\-Get\-Use\-Global\-Cell\-Ids ()}  
\item {\ttfamily obj.\-Set\-Merge\-Duplicate\-Points (int )}  
\item {\ttfamily int = obj.\-Get\-Merge\-Duplicate\-Points ()}  
\item {\ttfamily obj.\-Merge\-Duplicate\-Points\-On ()}  
\item {\ttfamily obj.\-Merge\-Duplicate\-Points\-Off ()}  
\item {\ttfamily obj.\-Set\-Total\-Number\-Of\-Data\-Sets (int )}  
\item {\ttfamily int = obj.\-Get\-Total\-Number\-Of\-Data\-Sets ()}  
\item {\ttfamily int = obj.\-Merge\-Data\-Set (vtk\-Data\-Set set)}  
\item {\ttfamily obj.\-Finish ()}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkmergedataobjectfilter}{}\section{vtk\-Merge\-Data\-Object\-Filter}\label{vtkgraphics_vtkmergedataobjectfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Merge\-Data\-Object\-Filter is a filter that merges the field from a vtk\-Data\-Object with a vtk\-Data\-Set. The resulting combined dataset can then be processed by other filters (e.\-g., vtk\-Field\-Data\-To\-Attribute\-Data\-Filter) to create attribute data like scalars, vectors, etc.

The filter operates as follows. The field data from the vtk\-Data\-Object is merged with the input's vtk\-Data\-Set and then placed in the output. You can choose to place the field data into the cell data field, the point data field, or the datasets field (i.\-e., the one inherited from vtk\-Data\-Set's superclass vtk\-Data\-Object). All this data shuffling occurs via reference counting, therefore memory is not copied.

One of the uses of this filter is to allow you to read/generate the structure of a dataset independent of the attributes. So, for example, you could store the dataset geometry/topology in one file, and field data in another. Then use this filter in combination with vtk\-Field\-Data\-To\-Attribute\-Data to create a dataset ready for processing in the visualization pipeline.

To create an instance of class vtk\-Merge\-Data\-Object\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMergeDataObjectFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Merge\-Data\-Object\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Merge\-Data\-Object\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Merge\-Data\-Object\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Merge\-Data\-Object\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Data\-Object (vtk\-Data\-Object object)} -\/ Specify the data object to merge with the input dataset.  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Data\-Object ()} -\/ Specify the data object to merge with the input dataset.  
\item {\ttfamily obj.\-Set\-Output\-Field (int )} -\/ Specify where to place the field data during the merge process. There are three choices\-: the field data associated with the vtk\-Data\-Object superclass; the point field attribute data; and the cell field attribute data.  
\item {\ttfamily int = obj.\-Get\-Output\-Field ()} -\/ Specify where to place the field data during the merge process. There are three choices\-: the field data associated with the vtk\-Data\-Object superclass; the point field attribute data; and the cell field attribute data.  
\item {\ttfamily obj.\-Set\-Output\-Field\-To\-Data\-Object\-Field ()} -\/ Specify where to place the field data during the merge process. There are three choices\-: the field data associated with the vtk\-Data\-Object superclass; the point field attribute data; and the cell field attribute data.  
\item {\ttfamily obj.\-Set\-Output\-Field\-To\-Point\-Data\-Field ()} -\/ Specify where to place the field data during the merge process. There are three choices\-: the field data associated with the vtk\-Data\-Object superclass; the point field attribute data; and the cell field attribute data.  
\item {\ttfamily obj.\-Set\-Output\-Field\-To\-Cell\-Data\-Field ()} -\/ Specify where to place the field data during the merge process. There are three choices\-: the field data associated with the vtk\-Data\-Object superclass; the point field attribute data; and the cell field attribute data.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkmergefields}{}\section{vtk\-Merge\-Fields}\label{vtkgraphics_vtkmergefields}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Merge\-Fields is used to merge mutliple field into one. The new field is put in the same field data as the original field. For example \begin{DoxyVerb} mf->SetOutputField("foo", vtkMergeFields::POINT_DATA);
 mf->SetNumberOfComponents(2);
 mf->Merge(0, "array1", 1);
 mf->Merge(1, "array2", 0);\end{DoxyVerb}
 will tell vtk\-Merge\-Fields to use the 2nd component of array1 and the 1st component of array2 to create a 2 component field called foo. The same can be done using Tcl\-: \begin{DoxyVerb} mf SetOutputField foo POINT_DATA
 mf Merge 0 array1 1
 mf Merge 1 array2 0

 Field locations: DATA_OBJECT, POINT_DATA, CELL_DATA\end{DoxyVerb}


To create an instance of class vtk\-Merge\-Fields, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMergeFields
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Merge\-Fields has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Merge\-Fields class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Merge\-Fields = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Merge\-Fields = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Output\-Field (string name, int field\-Loc)} -\/ The output field will have the given name and it will be in field\-Loc (the input fields also have to be in field\-Loc).  
\item {\ttfamily obj.\-Set\-Output\-Field (string name, string field\-Loc)} -\/ Helper method used by the other language bindings. Allows the caller to specify arguments as strings instead of enums.\-Returns an operation id which can later be used to remove the operation.  
\item {\ttfamily obj.\-Merge (int component, string array\-Name, int source\-Comp)} -\/ Add a component (array\-Name,source\-Comp) to the output field.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Components (int )} -\/ Set the number of the components in the output field. This has to be set before execution. Default value is 0.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components ()} -\/ Set the number of the components in the output field. This has to be set before execution. Default value is 0.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkmergefilter}{}\section{vtk\-Merge\-Filter}\label{vtkgraphics_vtkmergefilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Merge\-Filter is a filter that extracts separate components of data from different datasets and merges them into a single dataset. The output from this filter is of the same type as the input (i.\-e., vtk\-Data\-Set.) It treats both cell and point data set attributes.

To create an instance of class vtk\-Merge\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMergeFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Merge\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Merge\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Merge\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Merge\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Geometry (vtk\-Data\-Set input)} -\/ Specify object from which to extract geometry information. Old style. Use Set\-Geometry\-Connection() instead.  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Geometry ()} -\/ Specify object from which to extract geometry information. Old style. Use Set\-Geometry\-Connection() instead.  
\item {\ttfamily obj.\-Set\-Geometry\-Connection (vtk\-Algorithm\-Output alg\-Output)} -\/ Specify object from which to extract scalar information. Old style. Use Set\-Scalars\-Connection() instead.  
\item {\ttfamily obj.\-Set\-Scalars (vtk\-Data\-Set )} -\/ Specify object from which to extract scalar information. Old style. Use Set\-Scalars\-Connection() instead.  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Scalars ()} -\/ Specify object from which to extract scalar information. Old style. Use Set\-Scalars\-Connection() instead.  
\item {\ttfamily obj.\-Set\-Scalars\-Connection (vtk\-Algorithm\-Output alg\-Output)} -\/ Set / get the object from which to extract vector information. Old style. Use Set\-Vectors\-Connection() instead.  
\item {\ttfamily obj.\-Set\-Vectors (vtk\-Data\-Set )} -\/ Set / get the object from which to extract vector information. Old style. Use Set\-Vectors\-Connection() instead.  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Vectors ()} -\/ Set / get the object from which to extract vector information. Old style. Use Set\-Vectors\-Connection() instead.  
\item {\ttfamily obj.\-Set\-Vectors\-Connection (vtk\-Algorithm\-Output alg\-Output)} -\/ Set / get the object from which to extract normal information. Old style. Use Set\-Normals\-Connection() instead.  
\item {\ttfamily obj.\-Set\-Normals (vtk\-Data\-Set )} -\/ Set / get the object from which to extract normal information. Old style. Use Set\-Normals\-Connection() instead.  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Normals ()} -\/ Set / get the object from which to extract normal information. Old style. Use Set\-Normals\-Connection() instead.  
\item {\ttfamily obj.\-Set\-Normals\-Connection (vtk\-Algorithm\-Output alg\-Output)} -\/ Set / get the object from which to extract texture coordinates information. Old style. Use Set\-T\-Coords\-Connection() instead.  
\item {\ttfamily obj.\-Set\-T\-Coords (vtk\-Data\-Set )} -\/ Set / get the object from which to extract texture coordinates information. Old style. Use Set\-T\-Coords\-Connection() instead.  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-T\-Coords ()} -\/ Set / get the object from which to extract texture coordinates information. Old style. Use Set\-T\-Coords\-Connection() instead.  
\item {\ttfamily obj.\-Set\-T\-Coords\-Connection (vtk\-Algorithm\-Output alg\-Output)} -\/ Set / get the object from which to extract tensor data. Old style. Use Set\-Tensors\-Connection() instead.  
\item {\ttfamily obj.\-Set\-Tensors (vtk\-Data\-Set )} -\/ Set / get the object from which to extract tensor data. Old style. Use Set\-Tensors\-Connection() instead.  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Tensors ()} -\/ Set / get the object from which to extract tensor data. Old style. Use Set\-Tensors\-Connection() instead.  
\item {\ttfamily obj.\-Set\-Tensors\-Connection (vtk\-Algorithm\-Output alg\-Output)} -\/ Set the object from which to extract a field and the name of the field. Note that this does not create pipeline connectivity.  
\item {\ttfamily obj.\-Add\-Field (string name, vtk\-Data\-Set input)} -\/ Set the object from which to extract a field and the name of the field. Note that this does not create pipeline connectivity.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkmeshquality}{}\section{vtk\-Mesh\-Quality}\label{vtkgraphics_vtkmeshquality}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Mesh\-Quality computes one or more functions of (geometric) quality for each 2-\/\-D and 3-\/\-D cell (triangle, quadrilateral, tetrahedron, or hexahedron) of a mesh. These functions of quality are then averaged over the entire mesh. The minimum, average, maximum, and unbiased variance of quality for each type of cell is stored in the output mesh's Field\-Data. The Field\-Data arrays are named \char`\"{}\-Mesh Triangle Quality,\char`\"{} \char`\"{}\-Mesh Quadrilateral Quality,\char`\"{} \char`\"{}\-Mesh Tetrahedron Quality,\char`\"{} and \char`\"{}\-Mesh Hexahedron Quality.\char`\"{} Each array has a single tuple with 5 components. The first 4 components are the quality statistics mentioned above; the final value is the number of cells of the given type. This final component makes aggregation of statistics for distributed mesh data possible.

By default, the per-\/cell quality is added to the mesh's cell data, in an array named \char`\"{}\-Quality.\char`\"{} Cell types not supported by this filter will have an entry of 0. Use Save\-Cell\-Quality\-Off() to store only the final statistics.

This version of the filter written by Philippe Pebay and David Thompson overtakes an older version written by Leila Baghdadi, Hanif Ladak, and David Steinman at the Imaging Research Labs, Robarts Research Institute. That version only supported tetrahedral radius ratio. See the Compatibility\-Mode\-On() member for information on how to make this filter behave like the previous implementation. For more information on the triangle quality functions of this class, cf. Pebay \& Baker 2003, Analysis of triangle quality measures, Math Comp 72\-:244. For more information on the quadrangle quality functions of this class, cf. Pebay 2004, Planar Quadrangle Quality Measures, Eng Comp 20\-:2.

To create an instance of class vtk\-Mesh\-Quality, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMeshQuality
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Mesh\-Quality has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Mesh\-Quality class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Mesh\-Quality = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Mesh\-Quality = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Save\-Cell\-Quality (int )} -\/ This variable controls whether or not cell quality is stored as cell data in the resulting mesh or discarded (leaving only the aggregate quality average of the entire mesh, recorded in the Field\-Data).  
\item {\ttfamily int = obj.\-Get\-Save\-Cell\-Quality ()} -\/ This variable controls whether or not cell quality is stored as cell data in the resulting mesh or discarded (leaving only the aggregate quality average of the entire mesh, recorded in the Field\-Data).  
\item {\ttfamily obj.\-Save\-Cell\-Quality\-On ()} -\/ This variable controls whether or not cell quality is stored as cell data in the resulting mesh or discarded (leaving only the aggregate quality average of the entire mesh, recorded in the Field\-Data).  
\item {\ttfamily obj.\-Save\-Cell\-Quality\-Off ()} -\/ This variable controls whether or not cell quality is stored as cell data in the resulting mesh or discarded (leaving only the aggregate quality average of the entire mesh, recorded in the Field\-Data).  
\item {\ttfamily obj.\-Set\-Triangle\-Quality\-Measure (int )} -\/ Set/\-Get the particular estimator used to function the quality of triangles. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily int = obj.\-Get\-Triangle\-Quality\-Measure ()} -\/ Set/\-Get the particular estimator used to function the quality of triangles. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Triangle\-Quality\-Measure\-To\-Area ()} -\/ Set/\-Get the particular estimator used to function the quality of triangles. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Triangle\-Quality\-Measure\-To\-Edge\-Ratio ()} -\/ Set/\-Get the particular estimator used to function the quality of triangles. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Triangle\-Quality\-Measure\-To\-Aspect\-Ratio ()} -\/ Set/\-Get the particular estimator used to function the quality of triangles. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Triangle\-Quality\-Measure\-To\-Radius\-Ratio ()} -\/ Set/\-Get the particular estimator used to function the quality of triangles. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Triangle\-Quality\-Measure\-To\-Aspect\-Frobenius ()} -\/ Set/\-Get the particular estimator used to function the quality of triangles. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Triangle\-Quality\-Measure\-To\-Min\-Angle ()} -\/ Set/\-Get the particular estimator used to function the quality of triangles. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Triangle\-Quality\-Measure\-To\-Max\-Angle ()} -\/ Set/\-Get the particular estimator used to function the quality of triangles. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Triangle\-Quality\-Measure\-To\-Condition ()} -\/ Set/\-Get the particular estimator used to function the quality of triangles. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Triangle\-Quality\-Measure\-To\-Scaled\-Jacobian ()} -\/ Set/\-Get the particular estimator used to function the quality of triangles. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Triangle\-Quality\-Measure\-To\-Relative\-Size\-Squared ()} -\/ Set/\-Get the particular estimator used to function the quality of triangles. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Triangle\-Quality\-Measure\-To\-Shape ()} -\/ Set/\-Get the particular estimator used to function the quality of triangles. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Triangle\-Quality\-Measure\-To\-Shape\-And\-Size ()} -\/ Set/\-Get the particular estimator used to function the quality of triangles. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Triangle\-Quality\-Measure\-To\-Distortion ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure (int )} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily int = obj.\-Get\-Quad\-Quality\-Measure ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure\-To\-Edge\-Ratio ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure\-To\-Aspect\-Ratio ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure\-To\-Radius\-Ratio ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure\-To\-Med\-Aspect\-Frobenius ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure\-To\-Max\-Aspect\-Frobenius ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure\-To\-Max\-Edge\-Ratios ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure\-To\-Skew ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure\-To\-Taper ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure\-To\-Warpage ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure\-To\-Area ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure\-To\-Stretch ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure\-To\-Min\-Angle ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure\-To\-Max\-Angle ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure\-To\-Oddy ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure\-To\-Condition ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure\-To\-Jacobian ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure\-To\-Scaled\-Jacobian ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure\-To\-Shear ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure\-To\-Shape ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure\-To\-Relative\-Size\-Squared ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure\-To\-Shape\-And\-Size ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure\-To\-Shear\-And\-Size ()} -\/ Set/\-Get the particular estimator used to measure the quality of quadrilaterals. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-W\-A\-R\-P\-A\-G\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-R\-E\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-I\-N\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.

Scope\-: Except for V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, these estimators are intended for planar quadrilaterals only; use at your own risk if you really want to assess non-\/planar quadrilateral quality with those.  
\item {\ttfamily obj.\-Set\-Quad\-Quality\-Measure\-To\-Distortion ()} -\/ Set/\-Get the particular estimator used to measure the quality of tetrahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O (identical to Verdict's aspect ratio beta) and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-L\-L\-A\-P\-S\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-B\-E\-T\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-G\-A\-M\-M\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Tet\-Quality\-Measure (int )} -\/ Set/\-Get the particular estimator used to measure the quality of tetrahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O (identical to Verdict's aspect ratio beta) and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-L\-L\-A\-P\-S\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-B\-E\-T\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-G\-A\-M\-M\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily int = obj.\-Get\-Tet\-Quality\-Measure ()} -\/ Set/\-Get the particular estimator used to measure the quality of tetrahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O (identical to Verdict's aspect ratio beta) and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-L\-L\-A\-P\-S\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-B\-E\-T\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-G\-A\-M\-M\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Tet\-Quality\-Measure\-To\-Edge\-Ratio ()} -\/ Set/\-Get the particular estimator used to measure the quality of tetrahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O (identical to Verdict's aspect ratio beta) and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-L\-L\-A\-P\-S\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-B\-E\-T\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-G\-A\-M\-M\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Tet\-Quality\-Measure\-To\-Aspect\-Ratio ()} -\/ Set/\-Get the particular estimator used to measure the quality of tetrahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O (identical to Verdict's aspect ratio beta) and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-L\-L\-A\-P\-S\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-B\-E\-T\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-G\-A\-M\-M\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Tet\-Quality\-Measure\-To\-Radius\-Ratio ()} -\/ Set/\-Get the particular estimator used to measure the quality of tetrahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O (identical to Verdict's aspect ratio beta) and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-L\-L\-A\-P\-S\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-B\-E\-T\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-G\-A\-M\-M\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Tet\-Quality\-Measure\-To\-Aspect\-Frobenius ()} -\/ Set/\-Get the particular estimator used to measure the quality of tetrahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O (identical to Verdict's aspect ratio beta) and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-L\-L\-A\-P\-S\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-B\-E\-T\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-G\-A\-M\-M\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Tet\-Quality\-Measure\-To\-Min\-Angle ()} -\/ Set/\-Get the particular estimator used to measure the quality of tetrahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O (identical to Verdict's aspect ratio beta) and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-L\-L\-A\-P\-S\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-B\-E\-T\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-G\-A\-M\-M\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Tet\-Quality\-Measure\-To\-Collapse\-Ratio ()} -\/ Set/\-Get the particular estimator used to measure the quality of tetrahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O (identical to Verdict's aspect ratio beta) and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-L\-L\-A\-P\-S\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-B\-E\-T\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-G\-A\-M\-M\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Tet\-Quality\-Measure\-To\-Aspect\-Beta ()} -\/ Set/\-Get the particular estimator used to measure the quality of tetrahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O (identical to Verdict's aspect ratio beta) and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-L\-L\-A\-P\-S\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-B\-E\-T\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-G\-A\-M\-M\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Tet\-Quality\-Measure\-To\-Aspect\-Gamma ()} -\/ Set/\-Get the particular estimator used to measure the quality of tetrahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O (identical to Verdict's aspect ratio beta) and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-L\-L\-A\-P\-S\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-B\-E\-T\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-G\-A\-M\-M\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Tet\-Quality\-Measure\-To\-Volume ()} -\/ Set/\-Get the particular estimator used to measure the quality of tetrahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O (identical to Verdict's aspect ratio beta) and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-L\-L\-A\-P\-S\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-B\-E\-T\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-G\-A\-M\-M\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Tet\-Quality\-Measure\-To\-Condition ()} -\/ Set/\-Get the particular estimator used to measure the quality of tetrahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O (identical to Verdict's aspect ratio beta) and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-L\-L\-A\-P\-S\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-B\-E\-T\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-G\-A\-M\-M\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Tet\-Quality\-Measure\-To\-Jacobian ()} -\/ Set/\-Get the particular estimator used to measure the quality of tetrahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O (identical to Verdict's aspect ratio beta) and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-L\-L\-A\-P\-S\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-B\-E\-T\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-G\-A\-M\-M\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Tet\-Quality\-Measure\-To\-Scaled\-Jacobian ()} -\/ Set/\-Get the particular estimator used to measure the quality of tetrahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O (identical to Verdict's aspect ratio beta) and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-L\-L\-A\-P\-S\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-B\-E\-T\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-G\-A\-M\-M\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Tet\-Quality\-Measure\-To\-Shape ()} -\/ Set/\-Get the particular estimator used to measure the quality of tetrahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O (identical to Verdict's aspect ratio beta) and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-L\-L\-A\-P\-S\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-B\-E\-T\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-G\-A\-M\-M\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Tet\-Quality\-Measure\-To\-Relative\-Size\-Squared ()} -\/ Set/\-Get the particular estimator used to measure the quality of tetrahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O (identical to Verdict's aspect ratio beta) and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-L\-L\-A\-P\-S\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-B\-E\-T\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-G\-A\-M\-M\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Tet\-Quality\-Measure\-To\-Shape\-And\-Size ()} -\/ Set/\-Get the particular estimator used to measure the quality of tetrahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O (identical to Verdict's aspect ratio beta) and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-L\-L\-A\-P\-S\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-B\-E\-T\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-G\-A\-M\-M\-A, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Tet\-Quality\-Measure\-To\-Distortion ()} -\/ Set/\-Get the particular estimator used to measure the quality of hexahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-A\-G\-O\-N\-A\-L, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-M\-E\-N\-S\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Hex\-Quality\-Measure (int )} -\/ Set/\-Get the particular estimator used to measure the quality of hexahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-A\-G\-O\-N\-A\-L, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-M\-E\-N\-S\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily int = obj.\-Get\-Hex\-Quality\-Measure ()} -\/ Set/\-Get the particular estimator used to measure the quality of hexahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-A\-G\-O\-N\-A\-L, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-M\-E\-N\-S\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Hex\-Quality\-Measure\-To\-Edge\-Ratio ()} -\/ Set/\-Get the particular estimator used to measure the quality of hexahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-A\-G\-O\-N\-A\-L, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-M\-E\-N\-S\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Hex\-Quality\-Measure\-To\-Med\-Aspect\-Frobenius ()} -\/ Set/\-Get the particular estimator used to measure the quality of hexahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-A\-G\-O\-N\-A\-L, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-M\-E\-N\-S\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Hex\-Quality\-Measure\-To\-Max\-Aspect\-Frobenius ()} -\/ Set/\-Get the particular estimator used to measure the quality of hexahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-A\-G\-O\-N\-A\-L, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-M\-E\-N\-S\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Hex\-Quality\-Measure\-To\-Max\-Edge\-Ratios ()} -\/ Set/\-Get the particular estimator used to measure the quality of hexahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-A\-G\-O\-N\-A\-L, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-M\-E\-N\-S\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Hex\-Quality\-Measure\-To\-Skew ()} -\/ Set/\-Get the particular estimator used to measure the quality of hexahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-A\-G\-O\-N\-A\-L, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-M\-E\-N\-S\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Hex\-Quality\-Measure\-To\-Taper ()} -\/ Set/\-Get the particular estimator used to measure the quality of hexahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-A\-G\-O\-N\-A\-L, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-M\-E\-N\-S\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Hex\-Quality\-Measure\-To\-Volume ()} -\/ Set/\-Get the particular estimator used to measure the quality of hexahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-A\-G\-O\-N\-A\-L, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-M\-E\-N\-S\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Hex\-Quality\-Measure\-To\-Stretch ()} -\/ Set/\-Get the particular estimator used to measure the quality of hexahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-A\-G\-O\-N\-A\-L, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-M\-E\-N\-S\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Hex\-Quality\-Measure\-To\-Diagonal ()} -\/ Set/\-Get the particular estimator used to measure the quality of hexahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-A\-G\-O\-N\-A\-L, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-M\-E\-N\-S\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Hex\-Quality\-Measure\-To\-Dimension ()} -\/ Set/\-Get the particular estimator used to measure the quality of hexahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-A\-G\-O\-N\-A\-L, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-M\-E\-N\-S\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Hex\-Quality\-Measure\-To\-Oddy ()} -\/ Set/\-Get the particular estimator used to measure the quality of hexahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-A\-G\-O\-N\-A\-L, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-M\-E\-N\-S\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Hex\-Quality\-Measure\-To\-Condition ()} -\/ Set/\-Get the particular estimator used to measure the quality of hexahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-A\-G\-O\-N\-A\-L, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-M\-E\-N\-S\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Hex\-Quality\-Measure\-To\-Jacobian ()} -\/ Set/\-Get the particular estimator used to measure the quality of hexahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-A\-G\-O\-N\-A\-L, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-M\-E\-N\-S\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Hex\-Quality\-Measure\-To\-Scaled\-Jacobian ()} -\/ Set/\-Get the particular estimator used to measure the quality of hexahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-A\-G\-O\-N\-A\-L, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-M\-E\-N\-S\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Hex\-Quality\-Measure\-To\-Shear ()} -\/ Set/\-Get the particular estimator used to measure the quality of hexahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-A\-G\-O\-N\-A\-L, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-M\-E\-N\-S\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Hex\-Quality\-Measure\-To\-Shape ()} -\/ Set/\-Get the particular estimator used to measure the quality of hexahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-A\-G\-O\-N\-A\-L, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-M\-E\-N\-S\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Hex\-Quality\-Measure\-To\-Relative\-Size\-Squared ()} -\/ Set/\-Get the particular estimator used to measure the quality of hexahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-A\-G\-O\-N\-A\-L, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-M\-E\-N\-S\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Hex\-Quality\-Measure\-To\-Shape\-And\-Size ()} -\/ Set/\-Get the particular estimator used to measure the quality of hexahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-A\-G\-O\-N\-A\-L, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-M\-E\-N\-S\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Hex\-Quality\-Measure\-To\-Shear\-And\-Size ()} -\/ Set/\-Get the particular estimator used to measure the quality of hexahedra. The default is V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S and valid values also include V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-A\-S\-P\-E\-C\-T\-\_\-\-F\-R\-O\-B\-E\-N\-I\-U\-S, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-M\-A\-X\-\_\-\-E\-D\-G\-E\-\_\-\-R\-A\-T\-I\-O, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-K\-E\-W, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-T\-A\-P\-E\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-V\-O\-L\-U\-M\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-T\-R\-E\-T\-C\-H, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-A\-G\-O\-N\-A\-L, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-M\-E\-N\-S\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-O\-D\-D\-Y, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-C\-O\-N\-D\-I\-T\-I\-O\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-C\-A\-L\-E\-D\-\_\-\-J\-A\-C\-O\-B\-I\-A\-N, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-E\-L\-A\-T\-I\-V\-E\-\_\-\-S\-I\-Z\-E\-\_\-\-S\-Q\-U\-A\-R\-E\-D, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-A\-P\-E\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-S\-H\-E\-A\-R\-\_\-\-A\-N\-D\-\_\-\-S\-I\-Z\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-D\-I\-S\-T\-O\-R\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Hex\-Quality\-Measure\-To\-Distortion ()} -\/ This is a static function used to calculate the area of a triangle. It assumes that you pass the correct type of cell -- no type checking is performed because this method is called from the inner loop of the Execute() member function.  
\item {\ttfamily obj.\-Set\-Ratio (int r)} -\/ These methods are deprecated. Use Get/\-Set\-Save\-Cell\-Quality() instead.

Formerly, Set\-Ratio could be used to disable computation of the tetrahedral radius ratio so that volume alone could be computed. Now, cell quality is always computed, but you may decide not to store the result for each cell. This allows average cell quality of a mesh to be calculated without requiring per-\/cell storage.  
\item {\ttfamily int = obj.\-Get\-Ratio ()} -\/ These methods are deprecated. Use Get/\-Set\-Save\-Cell\-Quality() instead.

Formerly, Set\-Ratio could be used to disable computation of the tetrahedral radius ratio so that volume alone could be computed. Now, cell quality is always computed, but you may decide not to store the result for each cell. This allows average cell quality of a mesh to be calculated without requiring per-\/cell storage.  
\item {\ttfamily obj.\-Ratio\-On ()} -\/ These methods are deprecated. Use Get/\-Set\-Save\-Cell\-Quality() instead.

Formerly, Set\-Ratio could be used to disable computation of the tetrahedral radius ratio so that volume alone could be computed. Now, cell quality is always computed, but you may decide not to store the result for each cell. This allows average cell quality of a mesh to be calculated without requiring per-\/cell storage.  
\item {\ttfamily obj.\-Ratio\-Off ()} -\/ These methods are deprecated. Use Get/\-Set\-Save\-Cell\-Quality() instead.

Formerly, Set\-Ratio could be used to disable computation of the tetrahedral radius ratio so that volume alone could be computed. Now, cell quality is always computed, but you may decide not to store the result for each cell. This allows average cell quality of a mesh to be calculated without requiring per-\/cell storage.  
\item {\ttfamily obj.\-Set\-Volume (int cv)} -\/ These methods are deprecated. The functionality of computing cell volume is being removed until it can be computed for any 3\-D cell. (The previous implementation only worked for tetrahedra.)

For now, turning on the volume computation will put this filter into \char`\"{}compatibility mode,\char`\"{} where tetrahedral cell volume is stored in first component of each output tuple and the radius ratio is stored in the second component. You may also use Compatibility\-Mode\-On()/\-Off() to enter this mode. In this mode, cells other than tetrahedra will have report a volume of 0.\-0 (if volume computation is enabled).

By default, volume computation is disabled and compatibility mode is off, since it does not make a lot of sense for meshes with non-\/tetrahedral cells.  
\item {\ttfamily int = obj.\-Get\-Volume ()} -\/ These methods are deprecated. The functionality of computing cell volume is being removed until it can be computed for any 3\-D cell. (The previous implementation only worked for tetrahedra.)

For now, turning on the volume computation will put this filter into \char`\"{}compatibility mode,\char`\"{} where tetrahedral cell volume is stored in first component of each output tuple and the radius ratio is stored in the second component. You may also use Compatibility\-Mode\-On()/\-Off() to enter this mode. In this mode, cells other than tetrahedra will have report a volume of 0.\-0 (if volume computation is enabled).

By default, volume computation is disabled and compatibility mode is off, since it does not make a lot of sense for meshes with non-\/tetrahedral cells.  
\item {\ttfamily obj.\-Volume\-On ()} -\/ These methods are deprecated. The functionality of computing cell volume is being removed until it can be computed for any 3\-D cell. (The previous implementation only worked for tetrahedra.)

For now, turning on the volume computation will put this filter into \char`\"{}compatibility mode,\char`\"{} where tetrahedral cell volume is stored in first component of each output tuple and the radius ratio is stored in the second component. You may also use Compatibility\-Mode\-On()/\-Off() to enter this mode. In this mode, cells other than tetrahedra will have report a volume of 0.\-0 (if volume computation is enabled).

By default, volume computation is disabled and compatibility mode is off, since it does not make a lot of sense for meshes with non-\/tetrahedral cells.  
\item {\ttfamily obj.\-Volume\-Off ()} -\/ These methods are deprecated. The functionality of computing cell volume is being removed until it can be computed for any 3\-D cell. (The previous implementation only worked for tetrahedra.)

For now, turning on the volume computation will put this filter into \char`\"{}compatibility mode,\char`\"{} where tetrahedral cell volume is stored in first component of each output tuple and the radius ratio is stored in the second component. You may also use Compatibility\-Mode\-On()/\-Off() to enter this mode. In this mode, cells other than tetrahedra will have report a volume of 0.\-0 (if volume computation is enabled).

By default, volume computation is disabled and compatibility mode is off, since it does not make a lot of sense for meshes with non-\/tetrahedral cells.  
\item {\ttfamily obj.\-Set\-Compatibility\-Mode (int cm)} -\/ Compatibility\-Mode governs whether, when both a quality function and cell volume are to be stored as cell data, the two values are stored in a single array. When compatibility mode is off (the default), two separate arrays are used -- one labeled \char`\"{}\-Quality\char`\"{} and the other labeled \char`\"{}\-Volume\char`\"{}. When compatibility mode is on, both values are stored in a single array, with volume as the first component and quality as the second component.

Enabling Compatibility\-Mode changes the default tetrahedral quality function to V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O and turns volume computation on. (This matches the default behavior of the initial implementation of vtk\-Mesh\-Quality.) You may change quality function and volume computation without leaving compatibility mode.

Disabling compatibility mode does not affect the current volume computation or tetrahedral quality function settings.

The final caveat to Compatibility\-Mode is that regardless of its setting, the resulting array will be of type vtk\-Double\-Array rather than the original vtk\-Float\-Array. This is a safety function to keep the authors from diving off of the Combinatorial Coding Cliff into Certain Insanity.  
\item {\ttfamily int = obj.\-Get\-Compatibility\-Mode ()} -\/ Compatibility\-Mode governs whether, when both a quality function and cell volume are to be stored as cell data, the two values are stored in a single array. When compatibility mode is off (the default), two separate arrays are used -- one labeled \char`\"{}\-Quality\char`\"{} and the other labeled \char`\"{}\-Volume\char`\"{}. When compatibility mode is on, both values are stored in a single array, with volume as the first component and quality as the second component.

Enabling Compatibility\-Mode changes the default tetrahedral quality function to V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O and turns volume computation on. (This matches the default behavior of the initial implementation of vtk\-Mesh\-Quality.) You may change quality function and volume computation without leaving compatibility mode.

Disabling compatibility mode does not affect the current volume computation or tetrahedral quality function settings.

The final caveat to Compatibility\-Mode is that regardless of its setting, the resulting array will be of type vtk\-Double\-Array rather than the original vtk\-Float\-Array. This is a safety function to keep the authors from diving off of the Combinatorial Coding Cliff into Certain Insanity.  
\item {\ttfamily obj.\-Compatibility\-Mode\-On ()} -\/ Compatibility\-Mode governs whether, when both a quality function and cell volume are to be stored as cell data, the two values are stored in a single array. When compatibility mode is off (the default), two separate arrays are used -- one labeled \char`\"{}\-Quality\char`\"{} and the other labeled \char`\"{}\-Volume\char`\"{}. When compatibility mode is on, both values are stored in a single array, with volume as the first component and quality as the second component.

Enabling Compatibility\-Mode changes the default tetrahedral quality function to V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O and turns volume computation on. (This matches the default behavior of the initial implementation of vtk\-Mesh\-Quality.) You may change quality function and volume computation without leaving compatibility mode.

Disabling compatibility mode does not affect the current volume computation or tetrahedral quality function settings.

The final caveat to Compatibility\-Mode is that regardless of its setting, the resulting array will be of type vtk\-Double\-Array rather than the original vtk\-Float\-Array. This is a safety function to keep the authors from diving off of the Combinatorial Coding Cliff into Certain Insanity.  
\item {\ttfamily obj.\-Compatibility\-Mode\-Off ()} -\/ Compatibility\-Mode governs whether, when both a quality function and cell volume are to be stored as cell data, the two values are stored in a single array. When compatibility mode is off (the default), two separate arrays are used -- one labeled \char`\"{}\-Quality\char`\"{} and the other labeled \char`\"{}\-Volume\char`\"{}. When compatibility mode is on, both values are stored in a single array, with volume as the first component and quality as the second component.

Enabling Compatibility\-Mode changes the default tetrahedral quality function to V\-T\-K\-\_\-\-Q\-U\-A\-L\-I\-T\-Y\-\_\-\-R\-A\-D\-I\-U\-S\-\_\-\-R\-A\-T\-I\-O and turns volume computation on. (This matches the default behavior of the initial implementation of vtk\-Mesh\-Quality.) You may change quality function and volume computation without leaving compatibility mode.

Disabling compatibility mode does not affect the current volume computation or tetrahedral quality function settings.

The final caveat to Compatibility\-Mode is that regardless of its setting, the resulting array will be of type vtk\-Double\-Array rather than the original vtk\-Float\-Array. This is a safety function to keep the authors from diving off of the Combinatorial Coding Cliff into Certain Insanity.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkmodelmetadata}{}\section{vtk\-Model\-Metadata}\label{vtkgraphics_vtkmodelmetadata}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is inspired by the Exodus I\-I file format, but because this class does not depend on the Exodus library, it should be possible to use it to represent metadata for other dataset file formats. Sandia Labs uses it in their Exodus I\-I reader, their Exodus I\-I writer and their En\-Sight writer. vtk\-Distributed\-Data\-Filter looks for metadata attached to it's input and redistributes the metadata with the grid.

The fields in this class are those described in the document \char`\"{}\-E\-X\-O\-D\-U\-S I\-I\-: A Finite Element Data Model\char`\"{}, S\-A\-N\-D92-\/2137, November 1995.

Element and node I\-Ds stored in this object must be global I\-Ds, in the event that the original dataset was partitioned across many files.

One way to initialize this object is by using vtk\-Exodus\-Model (a Sandia class used by the Sandia Exodus reader). That class will take an open Exodus I\-I file and a vtk\-Unstructured\-Grid drawn from it and will set the required fields.

Alternatively, you can use all the Set$\ast$ methods to set the individual fields. This class does not copy the data, it simply uses your pointer. This class will free the storage associated with your pointer when the class is deleted. Most fields have sensible defaults. The only requirement is that if you are using this Model\-Metadata to write out an Exodus or En\-Sight file in parallel, you must Set\-Block\-Ids and Set\-Block\-Id\-Array\-Name. Your vtk\-Unstructured\-Grid must have a cell array giving the block I\-D for each cell.

To create an instance of class vtk\-Model\-Metadata, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkModelMetadata
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Model\-Metadata has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Model\-Metadata class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Model\-Metadata = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Model\-Metadata = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Print\-Global\-Information ()}  
\item {\ttfamily obj.\-Print\-Local\-Information ()}  
\item {\ttfamily obj.\-Set\-Title (string )} -\/ The title of the dataset.  
\item {\ttfamily obj.\-Add\-Information\-Line (string info)} -\/ Add an information line.  
\item {\ttfamily obj.\-Add\-Q\-A\-Record (string name, string version, string date, string time)} -\/ Add a Q\-A record. They fields are\-: The code name The code version number The date (M\-M/\-D\-D/\-Y\-Y or N\-U\-L\-L for today) The time (H\-H\-:\-M\-M\-:S\-S or N\-U\-L\-L for right now)  
\item {\ttfamily obj.\-Set\-Time\-Step\-Index (int )} -\/ Set the index of the time step represented by the results data in the file attached to this Model\-Metadata object. Time step indices start at 0 in this file, they start at 1 in an Exodus file.  
\item {\ttfamily obj.\-Set\-Time\-Steps (int number\-Of\-Time\-Steps, float time\-Step\-Values)} -\/ Set the total number of time steps in the file, and the value at each time step. We use your time step value array and delete it when we're done.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Blocks (int )} -\/ The number of blocks in the file. Set this before setting any of the block arrays.  
\item {\ttfamily obj.\-Set\-Block\-Ids (int )} -\/ An arbitrary integer I\-D for each block. We use your pointer, and free the memory when the object is freed.  
\item {\ttfamily int = obj.\-Set\-Block\-Number\-Of\-Elements (int nelts)} -\/ Set or get a pointer to a list of the number of elements in each block. We use your pointers, and free the memory when the object is freed.  
\item {\ttfamily obj.\-Set\-Block\-Nodes\-Per\-Element (int )} -\/ Set or get a pointer to a list of the number of nodes in the elements of each block. We use your pointers, and free the memory when the object is freed.  
\item {\ttfamily obj.\-Set\-Block\-Element\-Id\-List (int )} -\/ Set or get a pointer to a list global element I\-Ds for the elements in each block. We use your pointers, and free the memory when the object is freed.  
\item {\ttfamily int = obj.\-Set\-Block\-Number\-Of\-Attributes\-Per\-Element (int natts)} -\/ Set or get a pointer to a list of the number of attributes stored for the elements in each block. We use your pointers, and free the memory when the object is freed.  
\item {\ttfamily obj.\-Set\-Block\-Attributes (float )} -\/ Set or get a pointer to a list of the attributes for all blocks. The order of the list should be by block, by element within the block, by attribute. Omit blocks that don't have element attributes.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Node\-Sets (int )} -\/ The number of node sets in the file. Set this value before setting the various node set arrays.  
\item {\ttfamily obj.\-Set\-Node\-Set\-Ids (int )} -\/ Set or get the list the I\-Ds for each node set. Length of list is the number of node sets. We use your pointer, and free the memory when the object is freed.  
\item {\ttfamily int = obj.\-Set\-Node\-Set\-Size (int )} -\/ Set or get a pointer to a list of the number of nodes in each node set. We use your pointer, and free the memory when the object is freed.  
\item {\ttfamily obj.\-Set\-Node\-Set\-Node\-Id\-List (int )} -\/ Set or get a pointer to a concatenated list of the I\-Ds of all nodes in each node set. First list all I\-Ds in node set 0, then all I\-Ds in node set 1, and so on. We use your pointer, and free the memory when the object is freed.  
\item {\ttfamily int = obj.\-Set\-Node\-Set\-Number\-Of\-Distribution\-Factors (int )} -\/ Set or get a list of the number of distribution factors stored by each node set. This is either 0 or equal to the number of nodes in the node set. Length of list is number of node sets. We use your pointer, and free the memory when the object is freed.  
\item {\ttfamily obj.\-Set\-Node\-Set\-Distribution\-Factors (float )} -\/ Set or get a list of the distribution factors for the node sets. The list is organized by node set, and within node set by node. We use your pointer, and free the memory when the object is freed.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Side\-Sets (int )} -\/ Set or get the number of side sets. Set this value before setting any of the other side set arrays.  
\item {\ttfamily obj.\-Set\-Side\-Set\-Ids (int )} -\/ Set or get a pointer to a list giving the I\-D of each side set. We use your pointer, and free the memory when the object is freed.  
\item {\ttfamily int = obj.\-Set\-Side\-Set\-Size (int sizes)} -\/ Set or get a pointer to a list of the number of sides in each side set. We use your pointer, and free the memory when the object is freed.  
\item {\ttfamily int = obj.\-Set\-Side\-Set\-Number\-Of\-Distribution\-Factors (int df)} -\/ Set or get a pointer to a list of the number of distribution factors stored by each side set. Each side set has either no distribution factors, or 1 per node in the side set. We use your pointer, and free the memory when the object is freed.  
\item {\ttfamily obj.\-Set\-Side\-Set\-Element\-List (int )} -\/ Set or get a pointer to a list of the elements containing each side in each side set. The list is organized by side set, and within side set by element. We use your pointer, and free the memory when the object is freed.  
\item {\ttfamily obj.\-Set\-Side\-Set\-Side\-List (int )} -\/ Set or get a pointer to the element side for each side in the side set. (See the manual for the convention for numbering sides in different types of cells.) Side Ids are arranged by side set and within side set by side, and correspond to the Side\-Set\-Element\-List. We use your pointer, and free the memory when the object is freed.  
\item {\ttfamily obj.\-Set\-Side\-Set\-Num\-D\-F\-Per\-Side (int num\-Nodes)} -\/ Set or get a pointer to a list of the number of nodes in each side of each side set. This list is organized by side set, and within side set by side. We use your pointer, and free the memory when the object is freed.  
\item {\ttfamily obj.\-Set\-Side\-Set\-Distribution\-Factors (float )} -\/ Set or get a pointer to a list of all the distribution factors. For every side set that has distribution factors, the number of factors per node was given in the Side\-Set\-Number\-Of\-Distribution\-Factors array. If this number for a given side set is N, then for that side set we have N floating point values for each node for each side in the side set. If nodes are repeated in more than one side, we repeat the distribution factors. So this list is in order by side set, by node. We use your pointer, and free the memory when the object is freed.  
\item {\ttfamily obj.\-Set\-Block\-Property\-Value (int )} -\/ Set or get value for each variable for each block. List the integer values in order by variable and within variable by block.  
\item {\ttfamily obj.\-Set\-Node\-Set\-Property\-Value (int )} -\/ Set or get value for each variable for each node set. List the integer values in order by variable and within variable by node set.  
\item {\ttfamily obj.\-Set\-Side\-Set\-Property\-Value (int )} -\/ Set or get value for each variable for each side set. List the integer values in order by variable and within variable by side set.  
\item {\ttfamily obj.\-Set\-Global\-Variable\-Value (float f)} -\/ Set or get the values of the global variables at the current time step.  
\item {\ttfamily obj.\-Set\-Element\-Variable\-Truth\-Table (int )} -\/ A truth table indicating which element variables are defined for which blocks. The variables are all the original element variables that were in the file. The table is by block I\-D and within block I\-D by variable.  
\item {\ttfamily obj.\-Set\-All\-Variables\-Defined\-In\-All\-Blocks (int )} -\/ Instead of a truth table of all \char`\"{}1\char`\"{}s, you can set this instance variable to indicate that all variables are defined in all blocks.  
\item {\ttfamily obj.\-All\-Variables\-Defined\-In\-All\-Blocks\-On ()} -\/ Instead of a truth table of all \char`\"{}1\char`\"{}s, you can set this instance variable to indicate that all variables are defined in all blocks.  
\item {\ttfamily obj.\-All\-Variables\-Defined\-In\-All\-Blocks\-Off ()} -\/ Instead of a truth table of all \char`\"{}1\char`\"{}s, you can set this instance variable to indicate that all variables are defined in all blocks.  
\item {\ttfamily int = obj.\-Element\-Variable\-Is\-Defined\-In\-Block (string varname, int block\-Id)} -\/ If the element variable named is defined for the block Id provided (in the element variable truth table) return a 1, otherwise return a 0. If the variable name or block Id are unrecognized, the default value of 1 is returned. (This is an \char`\"{}original\char`\"{} variable name, from the file, not a name created for the vtk\-Unstructured\-Grid. Use Find\-Original$\ast$\-Variable\-Name to map between the two.)  
\item {\ttfamily string = obj.\-Find\-Original\-Element\-Variable\-Name (string name, int component)} -\/ Given the name of an element variable the vtk\-Unstructured\-Grid described by this Model\-Metadata, and a component number, give the name of the scalar array in the original file that turned into that component when the file was read into V\-T\-K.  
\item {\ttfamily string = obj.\-Find\-Original\-Node\-Variable\-Name (string name, int component)} -\/ Given the name of an node variable the vtk\-Unstructured\-Grid described by this Model\-Metadata, and a component number, give the name of the scalar array in the original file that turned into that component when the file was read into V\-T\-K.  
\item {\ttfamily obj.\-Pack (vtk\-Data\-Set ugrid)} -\/ Pack this object's metadata into a field array of a dataset.  
\item {\ttfamily int = obj.\-Unpack (vtk\-Data\-Set ugrid, int delete\-It)} -\/ Unpack the metadata stored in a dataset, and initialize this object with it. Return 1 if there's no metadata packed into the grid, 0 if O\-K. If delete\-It is O\-N, then delete the grid's packed data after unpacking it into the object.  
\item {\ttfamily int = obj.\-Add\-U\-Grid\-Element\-Variable (string ugrid\-Var\-Name, string orig\-Name, int num\-Components)} -\/ In order to write Exodus files from vtk\-Unstructured\-Grid objects that were read from Exodus files, we need to know the mapping from variable names in the U\-Grid to variable names in the Exodus file. (The Exodus reader combines scalar variables with similar names into vectors in the U\-Grid.) When building the U\-Grid to which this Model\-Metadata refers, add each element and node variable name with this call, including the name of original variable that yielded it's first component, and the number of components. If a variable is removed from the U\-Grid, remove it from the Model\-Metadata. (If this information is missing or incomplete, the Exodus\-I\-I\-Writer can still do something sensible in creating names for variables.)  
\item {\ttfamily int = obj.\-Remove\-U\-Grid\-Element\-Variable (string ugrid\-Var\-Name)} -\/ In order to write Exodus files from vtk\-Unstructured\-Grid objects that were read from Exodus files, we need to know the mapping from variable names in the U\-Grid to variable names in the Exodus file. (The Exodus reader combines scalar variables with similar names into vectors in the U\-Grid.) When building the U\-Grid to which this Model\-Metadata refers, add each element and node variable name with this call, including the name of original variable that yielded it's first component, and the number of components. If a variable is removed from the U\-Grid, remove it from the Model\-Metadata. (If this information is missing or incomplete, the Exodus\-I\-I\-Writer can still do something sensible in creating names for variables.)  
\item {\ttfamily int = obj.\-Add\-U\-Grid\-Node\-Variable (string ugrid\-Var\-Name, string orig\-Name, int num\-Components)}  
\item {\ttfamily int = obj.\-Remove\-U\-Grid\-Node\-Variable (string ugrid\-Var\-Name)}  
\item {\ttfamily int = obj.\-Merge\-Model\-Metadata (vtk\-Model\-Metadata em)} -\/ In V\-T\-K we take vtk\-Unstructured\-Grids and perform operations on them, including subsetting and merging grids. We need to modify the metadata object when this happens. Merge\-Model\-Metadata merges the supplied model (both global and local metadata) into this model. The models must be from the same file set.

Merge\-Model\-Metadata assumes that no element in one metadata object appears in the other. (It doesn't test for duplicate elements when merging the two metadata objects.)  
\item {\ttfamily int = obj.\-Merge\-Global\-Information (vtk\-Model\-Metadata em)} -\/ The metadata is divided into global metadata and local metadata. Merge\-Global\-Information merges just the global metadata of the supplied object into the global metadata of this object.  
\item {\ttfamily vtk\-Model\-Metadata = obj.\-Extract\-Model\-Metadata (vtk\-Id\-Type\-Array global\-Cell\-Id\-List, vtk\-Data\-Set grid)} -\/ Create and return a new metadata object which contains the information for the subset of global cell I\-Ds provided. We need the grid containing the cells so we can find point Ids as well, and also the name of the global cell I\-D array and the name of the global point I\-D array.  
\item {\ttfamily vtk\-Model\-Metadata = obj.\-Extract\-Global\-Metadata ()} -\/ Create and return a new metadata object containing only the global metadata of this metadata object.  
\item {\ttfamily obj.\-Free\-All\-Global\-Data ()} -\/ Free selected portions of the metadata when updating values in the vtk\-Model\-Metadata object. Resetting a particular field, (i.\-e. Set\-Node\-Set\-Ids) frees the previous setting, but if you are not setting every field, you may want to do a wholesale \char`\"{}\-Free\char`\"{} first.

Free\-All\-Global\-Data frees all the fields which don't depend on which time step, which blocks, or which variables are in the input. Free\-All\-Local\-Data frees all the fields which do depend on which time step, blocks or variables are in the input. Free\-Block\-Dependent\-Data frees all metadata fields which depend on which blocks were read in.  
\item {\ttfamily obj.\-Free\-All\-Local\-Data ()} -\/ Free selected portions of the metadata when updating values in the vtk\-Model\-Metadata object. Resetting a particular field, (i.\-e. Set\-Node\-Set\-Ids) frees the previous setting, but if you are not setting every field, you may want to do a wholesale \char`\"{}\-Free\char`\"{} first.

Free\-All\-Global\-Data frees all the fields which don't depend on which time step, which blocks, or which variables are in the input. Free\-All\-Local\-Data frees all the fields which do depend on which time step, blocks or variables are in the input. Free\-Block\-Dependent\-Data frees all metadata fields which depend on which blocks were read in.  
\item {\ttfamily obj.\-Free\-Block\-Dependent\-Data ()} -\/ Free selected portions of the metadata when updating values in the vtk\-Model\-Metadata object. Resetting a particular field, (i.\-e. Set\-Node\-Set\-Ids) frees the previous setting, but if you are not setting every field, you may want to do a wholesale \char`\"{}\-Free\char`\"{} first.

Free\-All\-Global\-Data frees all the fields which don't depend on which time step, which blocks, or which variables are in the input. Free\-All\-Local\-Data frees all the fields which do depend on which time step, blocks or variables are in the input. Free\-Block\-Dependent\-Data frees all metadata fields which depend on which blocks were read in.  
\item {\ttfamily obj.\-Free\-Original\-Element\-Variable\-Names ()} -\/ Free selected portions of the metadata when updating values in the vtk\-Model\-Metadata object. Resetting a particular field, (i.\-e. Set\-Node\-Set\-Ids) frees the previous setting, but if you are not setting every field, you may want to do a wholesale \char`\"{}\-Free\char`\"{} first.

Free\-All\-Global\-Data frees all the fields which don't depend on which time step, which blocks, or which variables are in the input. Free\-All\-Local\-Data frees all the fields which do depend on which time step, blocks or variables are in the input. Free\-Block\-Dependent\-Data frees all metadata fields which depend on which blocks were read in.  
\item {\ttfamily obj.\-Free\-Original\-Node\-Variable\-Names ()} -\/ Free selected portions of the metadata when updating values in the vtk\-Model\-Metadata object. Resetting a particular field, (i.\-e. Set\-Node\-Set\-Ids) frees the previous setting, but if you are not setting every field, you may want to do a wholesale \char`\"{}\-Free\char`\"{} first.

Free\-All\-Global\-Data frees all the fields which don't depend on which time step, which blocks, or which variables are in the input. Free\-All\-Local\-Data frees all the fields which do depend on which time step, blocks or variables are in the input. Free\-Block\-Dependent\-Data frees all metadata fields which depend on which blocks were read in.  
\item {\ttfamily obj.\-Free\-Used\-Element\-Variable\-Names ()} -\/ Free selected portions of the metadata when updating values in the vtk\-Model\-Metadata object. Resetting a particular field, (i.\-e. Set\-Node\-Set\-Ids) frees the previous setting, but if you are not setting every field, you may want to do a wholesale \char`\"{}\-Free\char`\"{} first.

Free\-All\-Global\-Data frees all the fields which don't depend on which time step, which blocks, or which variables are in the input. Free\-All\-Local\-Data frees all the fields which do depend on which time step, blocks or variables are in the input. Free\-Block\-Dependent\-Data frees all metadata fields which depend on which blocks were read in.  
\item {\ttfamily obj.\-Free\-Used\-Node\-Variable\-Names ()} -\/ Free selected portions of the metadata when updating values in the vtk\-Model\-Metadata object. Resetting a particular field, (i.\-e. Set\-Node\-Set\-Ids) frees the previous setting, but if you are not setting every field, you may want to do a wholesale \char`\"{}\-Free\char`\"{} first.

Free\-All\-Global\-Data frees all the fields which don't depend on which time step, which blocks, or which variables are in the input. Free\-All\-Local\-Data frees all the fields which do depend on which time step, blocks or variables are in the input. Free\-Block\-Dependent\-Data frees all metadata fields which depend on which blocks were read in.  
\item {\ttfamily obj.\-Free\-Used\-Element\-Variables ()} -\/ Free selected portions of the metadata when updating values in the vtk\-Model\-Metadata object. Resetting a particular field, (i.\-e. Set\-Node\-Set\-Ids) frees the previous setting, but if you are not setting every field, you may want to do a wholesale \char`\"{}\-Free\char`\"{} first.

Free\-All\-Global\-Data frees all the fields which don't depend on which time step, which blocks, or which variables are in the input. Free\-All\-Local\-Data frees all the fields which do depend on which time step, blocks or variables are in the input. Free\-Block\-Dependent\-Data frees all metadata fields which depend on which blocks were read in.  
\item {\ttfamily obj.\-Free\-Used\-Node\-Variables ()} -\/ Free selected portions of the metadata when updating values in the vtk\-Model\-Metadata object. Resetting a particular field, (i.\-e. Set\-Node\-Set\-Ids) frees the previous setting, but if you are not setting every field, you may want to do a wholesale \char`\"{}\-Free\char`\"{} first.

Free\-All\-Global\-Data frees all the fields which don't depend on which time step, which blocks, or which variables are in the input. Free\-All\-Local\-Data frees all the fields which do depend on which time step, blocks or variables are in the input. Free\-Block\-Dependent\-Data frees all metadata fields which depend on which blocks were read in.  
\item {\ttfamily obj.\-Reset ()} -\/ Set the object back to it's initial state  
\item {\ttfamily int = obj.\-Get\-Block\-Local\-Index (int id)} -\/ Block information is stored in arrays. This method returns the array index for a given block I\-D.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkmultiblockdatagroupfilter}{}\section{vtk\-Multi\-Block\-Data\-Group\-Filter}\label{vtkgraphics_vtkmultiblockdatagroupfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Multi\-Block\-Data\-Group\-Filter is an M to 1 filter that merges multiple input into one multi-\/group dataset. It will assign each input to one group of the multi-\/group dataset and will assign each update piece as a sub-\/block. For example, if there are two inputs and four update pieces, the output contains two groups with four datasets each.

To create an instance of class vtk\-Multi\-Block\-Data\-Group\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMultiBlockDataGroupFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Multi\-Block\-Data\-Group\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Data\-Group\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Multi\-Block\-Data\-Group\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Multi\-Block\-Data\-Group\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Input (vtk\-Data\-Object )} -\/ Add an input of this algorithm. Note that these methods support old-\/style pipeline connections. When writing new code you should use the more general vtk\-Algorithm\-::\-Add\-Input\-Connection(). See Set\-Input() for details.  
\item {\ttfamily obj.\-Add\-Input (int , vtk\-Data\-Object )} -\/ Add an input of this algorithm. Note that these methods support old-\/style pipeline connections. When writing new code you should use the more general vtk\-Algorithm\-::\-Add\-Input\-Connection(). See Set\-Input() for details.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkmultiblockmergefilter}{}\section{vtk\-Multi\-Block\-Merge\-Filter}\label{vtkgraphics_vtkmultiblockmergefilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Multi\-Block\-Merge\-Filter is an M to 1 filter similar to vtk\-Multi\-Block\-Data\-Group\-Filter. However where as that class creates N groups in the output for N inputs, this creates 1 group in the output with N datasets inside it. In actuality if the inputs have M blocks, this will produce M blocks, each of which has N datasets. Inside the merged group, the i'th data set comes from the i'th data set in the i'th input.

To create an instance of class vtk\-Multi\-Block\-Merge\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMultiBlockMergeFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Multi\-Block\-Merge\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Merge\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Multi\-Block\-Merge\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Multi\-Block\-Merge\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Input (vtk\-Data\-Object )} -\/ Add an input of this algorithm. Note that these methods support old-\/style pipeline connections. When writing new code you should use the more general vtk\-Algorithm\-::\-Add\-Input\-Connection(). See Set\-Input() for details.  
\item {\ttfamily obj.\-Add\-Input (int , vtk\-Data\-Object )} -\/ Add an input of this algorithm. Note that these methods support old-\/style pipeline connections. When writing new code you should use the more general vtk\-Algorithm\-::\-Add\-Input\-Connection(). See Set\-Input() for details.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkmultithreshold}{}\section{vtk\-Multi\-Threshold}\label{vtkgraphics_vtkmultithreshold}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This filter can be substituted for a chain of several vtk\-Threshold filters and can also perform more sophisticated subsetting operations. It generates a vtk\-Multi\-Block\-Data\-Set as its output. This multiblock dataset contains a vtk\-Unstructured\-Grid for each thresholded subset you request. A thresholded subset can be a set defined by an interval over a point or cell attribute of the mesh; these subsets are called Interval\-Sets. A thresholded subset can also be a boolean combination of one or more Interval\-Sets; these subsets are called Boolean\-Sets. Boolean\-Sets allow complex logic since their output can depend on multiple intervals over multiple variables defined on the input mesh. This is useful because it eliminates the need for thresholding several times and then appending the results, as can be required with vtk\-Threshold when one wants to remove some range of values (e.\-g., a notch filter). Cells are not repeated when they belong to more than one interval unless those intervals have different output grids.

Another advantage this filter provides over vtk\-Threshold is the ability to threshold on non-\/scalar (i.\-e., vector, tensor, etc.) attributes without first computing an array containing some norm of the desired attribute. vtk\-Multi\-Threshold provides $L_1$, $L_2$, and $L_{\infty}$ norms.

This filter makes a distinction between intermediate subsets and subsets that will be output to a grid. Each intermediate subset you create with Add\-Interval\-Set or Add\-Boolean\-Set is given a unique integer identifier (via the return values of these member functions). If you wish for a given set to be output, you must call Output\-Set and pass it one of these identifiers. The return of Output\-Set is the integer index of the output set in the multiblock dataset created by this filter.

For example, if an input mesh defined three attributes T, P, and s, one might wish to find cells that satisfy \char`\"{}\-T $<$ 320 \mbox{[}\-K\mbox{]} \&\& ( P $>$ 101 \mbox{[}k\-Pa\mbox{]} $|$$|$ s $<$ 0.\-1 \mbox{[}k\-J/kg/\-K\mbox{]} )\char`\"{}. To accomplish this with a vtk\-Multi\-Threshold filter, 
\begin{DoxyPre}
 vtkMultiThreshold* thr;
 int intervalSets[3];\end{DoxyPre}



\begin{DoxyPre} intervalSets[0] = thr->AddIntervalSet( vtkMath::NegInf(), 320., vtkMultiThreshold::CLOSED, vtkMultiThreshold::OPEN,
     vtkDataObject::FIELD\_ASSOCIATION\_POINTS, "T", 0, 1 );
 intervalSets[1] = thr->AddIntervalSet( 101., vtkMath::Inf(), vtkMultiThreshold::OPEN, vtkMultiThreshold::CLOSED,
     vtkDataObject::FIELD\_ASSOCIATION\_CELLS, "P", 0, 1 );
 intervalSets[2] = thr->AddIntervalSet( vtkMath::NegInf(), 0.1, vtkMultiThreshold::CLOSED, vtkMultiThreshold::OPEN,
     vtkDataObject::FIELD\_ASSOCIATION\_POINTS, "s", 0, 1 );\end{DoxyPre}



\begin{DoxyPre} int intermediate = thr->AddBooleanSet( vtkMultiThreshold::OR, 2, &intervalSets[1] );\end{DoxyPre}



\begin{DoxyPre} int intersection[2];
 intersection[0] = intervalSets[0];
 intersection[1] = intermediate;
 int outputSet = thr->AddBooleanSet( vtkMultiThreshold::AND, 2, intersection );\end{DoxyPre}



\begin{DoxyPre} int outputGridIndex = thr->OutputSet( outputSet );
 thr->Update();
 \end{DoxyPre}
 The result of this filter will be a multiblock dataset that contains a single child with the desired cells. If we had also called {\ttfamily thr-\/$>$Output\-Set( interval\-Sets\mbox{[}0\mbox{]} );}, there would be two child meshes and one would contain all cells with T $<$ 320 \mbox{[}K\mbox{]}. In that case, the output can be represented by this graph The filled rectangles represent sets that are output.

To create an instance of class vtk\-Multi\-Threshold, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMultiThreshold
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Multi\-Threshold has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Threshold class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Multi\-Threshold = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Multi\-Threshold = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Add\-Interval\-Set (double xmin, double xmax, int omin, int omax, int assoc, string array\-Name, int component, int all\-Scalars)} -\/ Add a mesh subset to be computed by thresholding an attribute of the input mesh. The subset can then be added to an output mesh with Ouput\-Set() or combined with other sets using Add\-Boolean\-Set. If you wish to include all cells with values below some number {\itshape a}, call with xmin set to vtk\-Math\-::\-Neg\-Inf() and xmax set to {\itshape a}. Similarly, if you wish to include all cells with values above some number {\itshape a}, call with xmin set to {\itshape a} and xmax set to vtk\-Math\-::\-Inf(). When specifying Inf() or Neg\-Inf() for an endpoint, it does not matter whether you specify and open or closed endpoint.

When creating intervals, any integers can be used for the I\-Ds of output meshes. All that matters is that the same I\-D be used if intervals should output to the same mesh. The outputs are ordered with ascending I\-Ds in output block 0.

It is possible to specify an invalid interval, in which case these routines will return -\/1. Invalid intervals occur when
\begin{DoxyItemize}
\item an array does not exist,
\item {\itshape center} is invalid,
\item {\itshape xmin} == {\itshape xmax} and {\itshape omin} and/or {\itshape omax} are vtk\-Multi\-Threshold\-::\-O\-P\-E\-N, or
\item {\itshape xmin} $>$ {\itshape xmax}.
\item {\itshape xmin} or {\itshape xmax} is not a number (i.\-e., I\-E\-E\-E Na\-N). Having both {\itshape xmin} and {\itshape xmax} equal Na\-N is allowed. vtk\-Math provides a portable way to specify I\-E\-E\-E infinities and Nan. Note that specifying an interval completely out of the bounds of an attribute is considered valid. In fact, it is occasionally useful to create a closed interval with both endpoints set to $\infty$ or both endpoints set to $-\infty$ in order to locate cells with problematic values.
\end{DoxyItemize}


\begin{DoxyParams}{Parameters}
{\em xmin} & The minimum attribute value \\
\hline
{\em xmax} & The maximum attribute value \\
\hline
{\em omin} & Whether the interval should be open or closed at {\itshape xmin}. Use vtk\-Multi\-Threshold\-::\-O\-P\-E\-N or vtk\-Multi\-Threshold\-::\-C\-L\-O\-S\-E\-D. \\
\hline
{\em omax} & Whether the interval should be open or closed at {\itshape xmax}. Use vtk\-Multi\-Threshold\-::\-O\-P\-E\-N or vtk\-Multi\-Threshold\-::\-C\-L\-O\-S\-E\-D. \\
\hline
{\em assoc} & One of vtk\-Data\-Object\-::\-F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-C\-E\-L\-L\-S or vtk\-Data\-Object\-::\-F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-P\-O\-I\-N\-T\-S indicating whether a point or cell array should be used. \\
\hline
{\em array\-Name} & The name of the array to use for thresholding \\
\hline
{\em attrib\-Type} & The attribute to use for thresholding. One of vtk\-Data\-Set\-Attributes\-::\-S\-C\-A\-L\-A\-R\-S, V\-E\-C\-T\-O\-R\-S, T\-E\-N\-S\-O\-R\-S, N\-O\-R\-M\-A\-L\-S, T\-C\-O\-O\-R\-D\-S, or G\-L\-O\-B\-A\-L\-I\-D\-S. \\
\hline
{\em component} & The number of the component to threshold on or one of the following enumerants for norms\-: L\-I\-N\-F\-I\-N\-I\-T\-Y\-\_\-\-N\-O\-R\-M, L2\-\_\-\-N\-O\-R\-M, L1\-\_\-\-N\-O\-R\-M. \\
\hline
{\em all\-Scalars} & When {\itshape center} is vtk\-Data\-Object\-::\-F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-P\-O\-I\-N\-T\-S, must all scalars be in the interval for the cell to be passed to the output, or just a single point's scalar? \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
An index used to identify the cells selected by the interval or -\/1 if the interval specification was invalid. If a valid value is returned, you may pass it to Output\-Set().  
\end{DoxyReturn}

\item {\ttfamily int = obj.\-Add\-Interval\-Set (double xmin, double xmax, int omin, int omax, int assoc, int attrib\-Type, int component, int all\-Scalars)} -\/ Add a mesh subset to be computed by thresholding an attribute of the input mesh. The subset can then be added to an output mesh with Ouput\-Set() or combined with other sets using Add\-Boolean\-Set. If you wish to include all cells with values below some number {\itshape a}, call with xmin set to vtk\-Math\-::\-Neg\-Inf() and xmax set to {\itshape a}. Similarly, if you wish to include all cells with values above some number {\itshape a}, call with xmin set to {\itshape a} and xmax set to vtk\-Math\-::\-Inf(). When specifying Inf() or Neg\-Inf() for an endpoint, it does not matter whether you specify and open or closed endpoint.

When creating intervals, any integers can be used for the I\-Ds of output meshes. All that matters is that the same I\-D be used if intervals should output to the same mesh. The outputs are ordered with ascending I\-Ds in output block 0.

It is possible to specify an invalid interval, in which case these routines will return -\/1. Invalid intervals occur when
\begin{DoxyItemize}
\item an array does not exist,
\item {\itshape center} is invalid,
\item {\itshape xmin} == {\itshape xmax} and {\itshape omin} and/or {\itshape omax} are vtk\-Multi\-Threshold\-::\-O\-P\-E\-N, or
\item {\itshape xmin} $>$ {\itshape xmax}.
\item {\itshape xmin} or {\itshape xmax} is not a number (i.\-e., I\-E\-E\-E Na\-N). Having both {\itshape xmin} and {\itshape xmax} equal Na\-N is allowed. vtk\-Math provides a portable way to specify I\-E\-E\-E infinities and Nan. Note that specifying an interval completely out of the bounds of an attribute is considered valid. In fact, it is occasionally useful to create a closed interval with both endpoints set to $\infty$ or both endpoints set to $-\infty$ in order to locate cells with problematic values.
\end{DoxyItemize}


\begin{DoxyParams}{Parameters}
{\em xmin} & The minimum attribute value \\
\hline
{\em xmax} & The maximum attribute value \\
\hline
{\em omin} & Whether the interval should be open or closed at {\itshape xmin}. Use vtk\-Multi\-Threshold\-::\-O\-P\-E\-N or vtk\-Multi\-Threshold\-::\-C\-L\-O\-S\-E\-D. \\
\hline
{\em omax} & Whether the interval should be open or closed at {\itshape xmax}. Use vtk\-Multi\-Threshold\-::\-O\-P\-E\-N or vtk\-Multi\-Threshold\-::\-C\-L\-O\-S\-E\-D. \\
\hline
{\em assoc} & One of vtk\-Data\-Object\-::\-F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-C\-E\-L\-L\-S or vtk\-Data\-Object\-::\-F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-P\-O\-I\-N\-T\-S indicating whether a point or cell array should be used. \\
\hline
{\em array\-Name} & The name of the array to use for thresholding \\
\hline
{\em attrib\-Type} & The attribute to use for thresholding. One of vtk\-Data\-Set\-Attributes\-::\-S\-C\-A\-L\-A\-R\-S, V\-E\-C\-T\-O\-R\-S, T\-E\-N\-S\-O\-R\-S, N\-O\-R\-M\-A\-L\-S, T\-C\-O\-O\-R\-D\-S, or G\-L\-O\-B\-A\-L\-I\-D\-S. \\
\hline
{\em component} & The number of the component to threshold on or one of the following enumerants for norms\-: L\-I\-N\-F\-I\-N\-I\-T\-Y\-\_\-\-N\-O\-R\-M, L2\-\_\-\-N\-O\-R\-M, L1\-\_\-\-N\-O\-R\-M. \\
\hline
{\em all\-Scalars} & When {\itshape center} is vtk\-Data\-Object\-::\-F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-P\-O\-I\-N\-T\-S, must all scalars be in the interval for the cell to be passed to the output, or just a single point's scalar? \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
An index used to identify the cells selected by the interval or -\/1 if the interval specification was invalid. If a valid value is returned, you may pass it to Output\-Set().  
\end{DoxyReturn}

\item {\ttfamily int = obj.\-Add\-Lowpass\-Interval\-Set (double xmax, int assoc, string array\-Name, int component, int all\-Scalars)} -\/ These convenience members make it easy to insert closed intervals. The \char`\"{}notch\char`\"{} interval is accomplished by creating a bandpass interval and applying a N\-A\-N\-D operation. In this case, the set I\-D returned in the N\-A\-N\-D operation set I\-D. Note that you can pass xmin == xmax when creating a bandpass threshold to retrieve elements matching exactly one value (since the intervals created by these routines are closed).  
\item {\ttfamily int = obj.\-Add\-Highpass\-Interval\-Set (double xmin, int assoc, string array\-Name, int component, int all\-Scalars)} -\/ These convenience members make it easy to insert closed intervals. The \char`\"{}notch\char`\"{} interval is accomplished by creating a bandpass interval and applying a N\-A\-N\-D operation. In this case, the set I\-D returned in the N\-A\-N\-D operation set I\-D. Note that you can pass xmin == xmax when creating a bandpass threshold to retrieve elements matching exactly one value (since the intervals created by these routines are closed).  
\item {\ttfamily int = obj.\-Add\-Bandpass\-Interval\-Set (double xmin, double xmax, int assoc, string array\-Name, int component, int all\-Scalars)} -\/ These convenience members make it easy to insert closed intervals. The \char`\"{}notch\char`\"{} interval is accomplished by creating a bandpass interval and applying a N\-A\-N\-D operation. In this case, the set I\-D returned in the N\-A\-N\-D operation set I\-D. Note that you can pass xmin == xmax when creating a bandpass threshold to retrieve elements matching exactly one value (since the intervals created by these routines are closed).  
\item {\ttfamily int = obj.\-Add\-Notch\-Interval\-Set (double xlo, double xhi, int assoc, string array\-Name, int component, int all\-Scalars)} -\/ These convenience members make it easy to insert closed intervals. The \char`\"{}notch\char`\"{} interval is accomplished by creating a bandpass interval and applying a N\-A\-N\-D operation. In this case, the set I\-D returned in the N\-A\-N\-D operation set I\-D. Note that you can pass xmin == xmax when creating a bandpass threshold to retrieve elements matching exactly one value (since the intervals created by these routines are closed).  
\item {\ttfamily int = obj.\-Add\-Boolean\-Set (int operation, int num\-Inputs, int inputs)} -\/ Create a new mesh subset using boolean operations on pre-\/existing sets.  
\item {\ttfamily int = obj.\-Output\-Set (int set\-Id)} -\/ Create an output mesh containing a boolean or interval subset of the input mesh.  
\item {\ttfamily obj.\-Reset ()} -\/ Remove all the intervals currently defined.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkobbdicer}{}\section{vtk\-O\-B\-B\-Dicer}\label{vtkgraphics_vtkobbdicer}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-O\-B\-B\-Dicer separates the cells of a dataset into spatially aggregated pieces using a Oriented Bounding Box (O\-B\-B). These pieces can then be operated on by other filters (e.\-g., vtk\-Threshold). One application is to break very large polygonal models into pieces and performing viewing and occlusion culling on the pieces.

Refer to the superclass documentation (vtk\-Dicer) for more information.

To create an instance of class vtk\-O\-B\-B\-Dicer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOBBDicer
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-O\-B\-B\-Dicer has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-B\-Dicer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-O\-B\-B\-Dicer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-O\-B\-B\-Dicer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkobbtree}{}\section{vtk\-O\-B\-B\-Tree}\label{vtkgraphics_vtkobbtree}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-O\-B\-B\-Tree is an object to generate oriented bounding box (O\-B\-B) trees. An oriented bounding box is a bounding box that does not necessarily line up along coordinate axes. The O\-B\-B tree is a hierarchical tree structure of such boxes, where deeper levels of O\-B\-B confine smaller regions of space.

To build the O\-B\-B, a recursive, top-\/down process is used. First, the root O\-B\-B is constructed by finding the mean and covariance matrix of the cells (and their points) that define the dataset. The eigenvectors of the covariance matrix are extracted, giving a set of three orthogonal vectors that define the tightest-\/fitting O\-B\-B. To create the two children O\-B\-B's, a split plane is found that (approximately) divides the number cells in half. These are then assigned to the children O\-B\-B's. This process then continues until the Max\-Level ivar limits the recursion, or no split plane can be found.

A good reference for O\-B\-B-\/trees is Gottschalk \& Manocha in Proceedings of Siggraph `96.

To create an instance of class vtk\-O\-B\-B\-Tree, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOBBTree
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-O\-B\-B\-Tree has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-B\-Tree class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-O\-B\-B\-Tree = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-O\-B\-B\-Tree = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Intersect\-With\-Line (double a0\mbox{[}3\mbox{]}, double a1\mbox{[}3\mbox{]}, vtk\-Points points, vtk\-Id\-List cell\-Ids)} -\/ Take the passed line segment and intersect it with the data set. This method assumes that the data set is a vtk\-Poly\-Data that describes a closed surface, and the intersection points that are returned in 'points' alternate between entrance points and exit points. The return value of the function is 0 if no intersections were found, -\/1 if point 'a0' lies inside the closed surface, or +1 if point 'a0' lies outside the closed surface. Either 'points' or 'cell\-Ids' can be set to N\-U\-L\-L if you don't want to receive that information.  
\item {\ttfamily obj.\-Compute\-O\-B\-B (vtk\-Data\-Set input, double corner\mbox{[}3\mbox{]}, double max\mbox{[}3\mbox{]}, double mid\mbox{[}3\mbox{]}, double min\mbox{[}3\mbox{]}, double size\mbox{[}3\mbox{]})} -\/ Compute an O\-B\-B for the input dataset using the cells in the data. Return the corner point and the three axes defining the orientation of the O\-B\-B. Also return a sorted list of relative \char`\"{}sizes\char`\"{} of axes for comparison purposes.  
\item {\ttfamily int = obj.\-Inside\-Or\-Outside (double point\mbox{[}3\mbox{]})} -\/ Determine whether a point is inside or outside the data used to build this O\-B\-B tree. The data must be a closed surface vtk\-Poly\-Data data set. The return value is +1 if outside, -\/1 if inside, and 0 if undecided.  
\item {\ttfamily obj.\-Free\-Search\-Structure ()} -\/ Satisfy locator's abstract interface, see vtk\-Locator.  
\item {\ttfamily obj.\-Build\-Locator ()} -\/ Satisfy locator's abstract interface, see vtk\-Locator.  
\item {\ttfamily obj.\-Generate\-Representation (int level, vtk\-Poly\-Data pd)} -\/ Create polygonal representation for O\-B\-B tree at specified level. If level $<$ 0, then the leaf O\-B\-B nodes will be gathered. The aspect ratio (ar) and line diameter (d) are used to control the building of the representation. If a O\-B\-B node edge ratio's are greater than ar, then the dimension of the O\-B\-B is collapsed (O\-B\-B-\/$>$plane-\/$>$line). A \char`\"{}line\char`\"{} O\-B\-B will be represented either as two crossed polygons, or as a line, depending on the relative diameter of the O\-B\-B compared to the diameter (d).  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkoutlinecornerfilter}{}\section{vtk\-Outline\-Corner\-Filter}\label{vtkgraphics_vtkoutlinecornerfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Outline\-Corner\-Filter is a filter that generates wireframe outline corners of any data set. The outline consists of the eight corners of the dataset bounding box.

To create an instance of class vtk\-Outline\-Corner\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOutlineCornerFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Outline\-Corner\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Outline\-Corner\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Outline\-Corner\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Outline\-Corner\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Corner\-Factor (double )} -\/ Set/\-Get the factor that controls the relative size of the corners to the length of the corresponding bounds  
\item {\ttfamily double = obj.\-Get\-Corner\-Factor\-Min\-Value ()} -\/ Set/\-Get the factor that controls the relative size of the corners to the length of the corresponding bounds  
\item {\ttfamily double = obj.\-Get\-Corner\-Factor\-Max\-Value ()} -\/ Set/\-Get the factor that controls the relative size of the corners to the length of the corresponding bounds  
\item {\ttfamily double = obj.\-Get\-Corner\-Factor ()} -\/ Set/\-Get the factor that controls the relative size of the corners to the length of the corresponding bounds  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkoutlinecornersource}{}\section{vtk\-Outline\-Corner\-Source}\label{vtkgraphics_vtkoutlinecornersource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Outline\-Corner\-Source creates wireframe outline corners around a user-\/specified bounding box.

To create an instance of class vtk\-Outline\-Corner\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOutlineCornerSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Outline\-Corner\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Outline\-Corner\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Outline\-Corner\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Outline\-Corner\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Corner\-Factor (double )} -\/ Set/\-Get the factor that controls the relative size of the corners to the length of the corresponding bounds  
\item {\ttfamily double = obj.\-Get\-Corner\-Factor\-Min\-Value ()} -\/ Set/\-Get the factor that controls the relative size of the corners to the length of the corresponding bounds  
\item {\ttfamily double = obj.\-Get\-Corner\-Factor\-Max\-Value ()} -\/ Set/\-Get the factor that controls the relative size of the corners to the length of the corresponding bounds  
\item {\ttfamily double = obj.\-Get\-Corner\-Factor ()} -\/ Set/\-Get the factor that controls the relative size of the corners to the length of the corresponding bounds  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkoutlinefilter}{}\section{vtk\-Outline\-Filter}\label{vtkgraphics_vtkoutlinefilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Outline\-Filter is a filter that generates a wireframe outline of any data set. The outline consists of the twelve edges of the dataset bounding box.

To create an instance of class vtk\-Outline\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOutlineFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Outline\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Outline\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Outline\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Outline\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Generate\-Faces (int )} -\/ Generate solid faces for the box. This is off by default.  
\item {\ttfamily obj.\-Generate\-Faces\-On ()} -\/ Generate solid faces for the box. This is off by default.  
\item {\ttfamily obj.\-Generate\-Faces\-Off ()} -\/ Generate solid faces for the box. This is off by default.  
\item {\ttfamily int = obj.\-Get\-Generate\-Faces ()} -\/ Generate solid faces for the box. This is off by default.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkoutlinesource}{}\section{vtk\-Outline\-Source}\label{vtkgraphics_vtkoutlinesource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Outline\-Source creates a wireframe outline around a user-\/specified bounding box. The outline may be created aligned with the \{x,y,z\} axis -\/ in which case it is defined by the 6 bounds \{xmin,xmax,ymin,ymax,zmin,zmax\} via Set\-Bounds(). Alternatively, the box may be arbitrarily aligned, in which case it should be set via the Set\-Corners() member.

To create an instance of class vtk\-Outline\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOutlineSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Outline\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Outline\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Outline\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Outline\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Box\-Type (int )} -\/ Set box type to Axis\-Aligned (default) or Oriented. Use the method Set\-Bounds() with Axis\-Aligned mode, and Set\-Corners() with Oriented mode.  
\item {\ttfamily int = obj.\-Get\-Box\-Type ()} -\/ Set box type to Axis\-Aligned (default) or Oriented. Use the method Set\-Bounds() with Axis\-Aligned mode, and Set\-Corners() with Oriented mode.  
\item {\ttfamily obj.\-Set\-Box\-Type\-To\-Axis\-Aligned ()} -\/ Set box type to Axis\-Aligned (default) or Oriented. Use the method Set\-Bounds() with Axis\-Aligned mode, and Set\-Corners() with Oriented mode.  
\item {\ttfamily obj.\-Set\-Box\-Type\-To\-Oriented ()} -\/ Specify the bounds of the box to be used in Axis Aligned mode.  
\item {\ttfamily obj.\-Set\-Bounds (double , double , double , double , double , double )} -\/ Specify the bounds of the box to be used in Axis Aligned mode.  
\item {\ttfamily obj.\-Set\-Bounds (double a\mbox{[}6\mbox{]})} -\/ Specify the bounds of the box to be used in Axis Aligned mode.  
\item {\ttfamily double = obj. Get\-Bounds ()} -\/ Specify the bounds of the box to be used in Axis Aligned mode.  
\item {\ttfamily obj.\-Set\-Corners (double \mbox{[}24\mbox{]})} -\/ Specify the corners of the outline when in Oriented mode, the values are supplied as 8$\ast$3 double values The correct corner ordering is using \{x,y,z\} convention for the unit cube as follows\-: \{0,0,0\},\{1,0,0\},\{0,1,0\},\{1,1,0\},\{0,0,1\},\{1,0,1\},\{0,1,1\},\{1,1,1\}.  
\item {\ttfamily double = obj. Get\-Corners ()} -\/ Specify the corners of the outline when in Oriented mode, the values are supplied as 8$\ast$3 double values The correct corner ordering is using \{x,y,z\} convention for the unit cube as follows\-: \{0,0,0\},\{1,0,0\},\{0,1,0\},\{1,1,0\},\{0,0,1\},\{1,0,1\},\{0,1,1\},\{1,1,1\}.  
\item {\ttfamily obj.\-Set\-Generate\-Faces (int )} -\/ Generate solid faces for the box. This is off by default.  
\item {\ttfamily obj.\-Generate\-Faces\-On ()} -\/ Generate solid faces for the box. This is off by default.  
\item {\ttfamily obj.\-Generate\-Faces\-Off ()} -\/ Generate solid faces for the box. This is off by default.  
\item {\ttfamily int = obj.\-Get\-Generate\-Faces ()} -\/ Generate solid faces for the box. This is off by default.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkparametricfunctionsource}{}\section{vtk\-Parametric\-Function\-Source}\label{vtkgraphics_vtkparametricfunctionsource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class tessellates parametric functions. The user must specify how many points in the parametric coordinate directions are required (i.\-e., the resolution), and the mode to use to generate scalars.

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

To create an instance of class vtk\-Parametric\-Function\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkParametricFunctionSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Parametric\-Function\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Parametric\-Function\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Parametric\-Function\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Parametric\-Function\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Parametric\-Function (vtk\-Parametric\-Function )} -\/ Specify the parametric function to use to generate the tessellation.  
\item {\ttfamily vtk\-Parametric\-Function = obj.\-Get\-Parametric\-Function ()} -\/ Specify the parametric function to use to generate the tessellation.  
\item {\ttfamily obj.\-Set\-U\-Resolution (int )} -\/ Set/\-Get the number of subdivisions / tessellations in the u parametric direction. Note that the number of tessellant points in the u direction is the U\-Resolution + 1.  
\item {\ttfamily int = obj.\-Get\-U\-Resolution ()} -\/ Set/\-Get the number of subdivisions / tessellations in the u parametric direction. Note that the number of tessellant points in the u direction is the U\-Resolution + 1.  
\item {\ttfamily obj.\-Set\-V\-Resolution (int )} -\/ Set/\-Get the number of subdivisions / tessellations in the v parametric direction. Note that the number of tessellant points in the v direction is the V\-Resolution + 1.  
\item {\ttfamily int = obj.\-Get\-V\-Resolution ()} -\/ Set/\-Get the number of subdivisions / tessellations in the v parametric direction. Note that the number of tessellant points in the v direction is the V\-Resolution + 1.  
\item {\ttfamily obj.\-Set\-W\-Resolution (int )} -\/ Set/\-Get the number of subdivisions / tessellations in the w parametric direction. Note that the number of tessellant points in the w direction is the W\-Resolution + 1.  
\item {\ttfamily int = obj.\-Get\-W\-Resolution ()} -\/ Set/\-Get the number of subdivisions / tessellations in the w parametric direction. Note that the number of tessellant points in the w direction is the W\-Resolution + 1.  
\item {\ttfamily obj.\-Generate\-Texture\-Coordinates\-On ()} -\/ Set/\-Get the generation of texture coordinates. This is off by default. Note that this is only applicable to parametric surfaces whose parametric dimension is 2. Note that texturing may fail in some cases.  
\item {\ttfamily obj.\-Generate\-Texture\-Coordinates\-Off ()} -\/ Set/\-Get the generation of texture coordinates. This is off by default. Note that this is only applicable to parametric surfaces whose parametric dimension is 2. Note that texturing may fail in some cases.  
\item {\ttfamily obj.\-Set\-Generate\-Texture\-Coordinates (int )} -\/ Set/\-Get the generation of texture coordinates. This is off by default. Note that this is only applicable to parametric surfaces whose parametric dimension is 2. Note that texturing may fail in some cases.  
\item {\ttfamily int = obj.\-Get\-Generate\-Texture\-Coordinates ()} -\/ Set/\-Get the generation of texture coordinates. This is off by default. Note that this is only applicable to parametric surfaces whose parametric dimension is 2. Note that texturing may fail in some cases.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode (int )} -\/ Get/\-Set the mode used for the scalar data. The options are\-: S\-C\-A\-L\-A\-R\-\_\-\-N\-O\-N\-E, (default) scalars are not generated. S\-C\-A\-L\-A\-R\-\_\-\-U, the scalar is set to the u-\/value. S\-C\-A\-L\-A\-R\-\_\-\-V, the scalar is set to the v-\/value. S\-C\-A\-L\-A\-R\-\_\-\-U0, the scalar is set to 1 if u = (u\-\_\-max -\/ u\-\_\-min)/2 = u\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-V0, the scalar is set to 1 if v = (v\-\_\-max -\/ v\-\_\-min)/2 = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-U0\-V0, the scalar is set to 1 if u == u\-\_\-avg, 2 if v == v\-\_\-avg, 3 if u = u\-\_\-avg \&\& v = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-M\-O\-D\-U\-L\-U\-S, the scalar is set to (sqrt(u$\ast$u+v$\ast$v)), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-P\-H\-A\-S\-E, the scalar is set to (atan2(v,u)) (in degrees, 0 to 360), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-Q\-U\-A\-D\-R\-A\-N\-T, the scalar is set to 1, 2, 3 or 4 depending upon the quadrant of the point (u,v). S\-C\-A\-L\-A\-R\-\_\-\-X, the scalar is set to the x-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Y, the scalar is set to the y-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Z, the scalar is set to the z-\/value. S\-C\-A\-L\-A\-R\-\_\-\-D\-I\-S\-T\-A\-N\-C\-E, the scalar is set to (sqrt(x$\ast$x+y$\ast$y+z$\ast$z)). I.\-e. distance from the origin. S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D, the scalar is set to the value returned from Evaluate\-Scalar().  
\item {\ttfamily int = obj.\-Get\-Scalar\-Mode\-Min\-Value ()} -\/ Get/\-Set the mode used for the scalar data. The options are\-: S\-C\-A\-L\-A\-R\-\_\-\-N\-O\-N\-E, (default) scalars are not generated. S\-C\-A\-L\-A\-R\-\_\-\-U, the scalar is set to the u-\/value. S\-C\-A\-L\-A\-R\-\_\-\-V, the scalar is set to the v-\/value. S\-C\-A\-L\-A\-R\-\_\-\-U0, the scalar is set to 1 if u = (u\-\_\-max -\/ u\-\_\-min)/2 = u\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-V0, the scalar is set to 1 if v = (v\-\_\-max -\/ v\-\_\-min)/2 = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-U0\-V0, the scalar is set to 1 if u == u\-\_\-avg, 2 if v == v\-\_\-avg, 3 if u = u\-\_\-avg \&\& v = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-M\-O\-D\-U\-L\-U\-S, the scalar is set to (sqrt(u$\ast$u+v$\ast$v)), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-P\-H\-A\-S\-E, the scalar is set to (atan2(v,u)) (in degrees, 0 to 360), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-Q\-U\-A\-D\-R\-A\-N\-T, the scalar is set to 1, 2, 3 or 4 depending upon the quadrant of the point (u,v). S\-C\-A\-L\-A\-R\-\_\-\-X, the scalar is set to the x-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Y, the scalar is set to the y-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Z, the scalar is set to the z-\/value. S\-C\-A\-L\-A\-R\-\_\-\-D\-I\-S\-T\-A\-N\-C\-E, the scalar is set to (sqrt(x$\ast$x+y$\ast$y+z$\ast$z)). I.\-e. distance from the origin. S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D, the scalar is set to the value returned from Evaluate\-Scalar().  
\item {\ttfamily int = obj.\-Get\-Scalar\-Mode\-Max\-Value ()} -\/ Get/\-Set the mode used for the scalar data. The options are\-: S\-C\-A\-L\-A\-R\-\_\-\-N\-O\-N\-E, (default) scalars are not generated. S\-C\-A\-L\-A\-R\-\_\-\-U, the scalar is set to the u-\/value. S\-C\-A\-L\-A\-R\-\_\-\-V, the scalar is set to the v-\/value. S\-C\-A\-L\-A\-R\-\_\-\-U0, the scalar is set to 1 if u = (u\-\_\-max -\/ u\-\_\-min)/2 = u\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-V0, the scalar is set to 1 if v = (v\-\_\-max -\/ v\-\_\-min)/2 = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-U0\-V0, the scalar is set to 1 if u == u\-\_\-avg, 2 if v == v\-\_\-avg, 3 if u = u\-\_\-avg \&\& v = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-M\-O\-D\-U\-L\-U\-S, the scalar is set to (sqrt(u$\ast$u+v$\ast$v)), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-P\-H\-A\-S\-E, the scalar is set to (atan2(v,u)) (in degrees, 0 to 360), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-Q\-U\-A\-D\-R\-A\-N\-T, the scalar is set to 1, 2, 3 or 4 depending upon the quadrant of the point (u,v). S\-C\-A\-L\-A\-R\-\_\-\-X, the scalar is set to the x-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Y, the scalar is set to the y-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Z, the scalar is set to the z-\/value. S\-C\-A\-L\-A\-R\-\_\-\-D\-I\-S\-T\-A\-N\-C\-E, the scalar is set to (sqrt(x$\ast$x+y$\ast$y+z$\ast$z)). I.\-e. distance from the origin. S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D, the scalar is set to the value returned from Evaluate\-Scalar().  
\item {\ttfamily int = obj.\-Get\-Scalar\-Mode ()} -\/ Get/\-Set the mode used for the scalar data. The options are\-: S\-C\-A\-L\-A\-R\-\_\-\-N\-O\-N\-E, (default) scalars are not generated. S\-C\-A\-L\-A\-R\-\_\-\-U, the scalar is set to the u-\/value. S\-C\-A\-L\-A\-R\-\_\-\-V, the scalar is set to the v-\/value. S\-C\-A\-L\-A\-R\-\_\-\-U0, the scalar is set to 1 if u = (u\-\_\-max -\/ u\-\_\-min)/2 = u\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-V0, the scalar is set to 1 if v = (v\-\_\-max -\/ v\-\_\-min)/2 = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-U0\-V0, the scalar is set to 1 if u == u\-\_\-avg, 2 if v == v\-\_\-avg, 3 if u = u\-\_\-avg \&\& v = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-M\-O\-D\-U\-L\-U\-S, the scalar is set to (sqrt(u$\ast$u+v$\ast$v)), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-P\-H\-A\-S\-E, the scalar is set to (atan2(v,u)) (in degrees, 0 to 360), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-Q\-U\-A\-D\-R\-A\-N\-T, the scalar is set to 1, 2, 3 or 4 depending upon the quadrant of the point (u,v). S\-C\-A\-L\-A\-R\-\_\-\-X, the scalar is set to the x-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Y, the scalar is set to the y-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Z, the scalar is set to the z-\/value. S\-C\-A\-L\-A\-R\-\_\-\-D\-I\-S\-T\-A\-N\-C\-E, the scalar is set to (sqrt(x$\ast$x+y$\ast$y+z$\ast$z)). I.\-e. distance from the origin. S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D, the scalar is set to the value returned from Evaluate\-Scalar().  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-None (void )} -\/ Get/\-Set the mode used for the scalar data. The options are\-: S\-C\-A\-L\-A\-R\-\_\-\-N\-O\-N\-E, (default) scalars are not generated. S\-C\-A\-L\-A\-R\-\_\-\-U, the scalar is set to the u-\/value. S\-C\-A\-L\-A\-R\-\_\-\-V, the scalar is set to the v-\/value. S\-C\-A\-L\-A\-R\-\_\-\-U0, the scalar is set to 1 if u = (u\-\_\-max -\/ u\-\_\-min)/2 = u\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-V0, the scalar is set to 1 if v = (v\-\_\-max -\/ v\-\_\-min)/2 = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-U0\-V0, the scalar is set to 1 if u == u\-\_\-avg, 2 if v == v\-\_\-avg, 3 if u = u\-\_\-avg \&\& v = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-M\-O\-D\-U\-L\-U\-S, the scalar is set to (sqrt(u$\ast$u+v$\ast$v)), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-P\-H\-A\-S\-E, the scalar is set to (atan2(v,u)) (in degrees, 0 to 360), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-Q\-U\-A\-D\-R\-A\-N\-T, the scalar is set to 1, 2, 3 or 4 depending upon the quadrant of the point (u,v). S\-C\-A\-L\-A\-R\-\_\-\-X, the scalar is set to the x-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Y, the scalar is set to the y-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Z, the scalar is set to the z-\/value. S\-C\-A\-L\-A\-R\-\_\-\-D\-I\-S\-T\-A\-N\-C\-E, the scalar is set to (sqrt(x$\ast$x+y$\ast$y+z$\ast$z)). I.\-e. distance from the origin. S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D, the scalar is set to the value returned from Evaluate\-Scalar().  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-U (void )} -\/ Get/\-Set the mode used for the scalar data. The options are\-: S\-C\-A\-L\-A\-R\-\_\-\-N\-O\-N\-E, (default) scalars are not generated. S\-C\-A\-L\-A\-R\-\_\-\-U, the scalar is set to the u-\/value. S\-C\-A\-L\-A\-R\-\_\-\-V, the scalar is set to the v-\/value. S\-C\-A\-L\-A\-R\-\_\-\-U0, the scalar is set to 1 if u = (u\-\_\-max -\/ u\-\_\-min)/2 = u\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-V0, the scalar is set to 1 if v = (v\-\_\-max -\/ v\-\_\-min)/2 = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-U0\-V0, the scalar is set to 1 if u == u\-\_\-avg, 2 if v == v\-\_\-avg, 3 if u = u\-\_\-avg \&\& v = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-M\-O\-D\-U\-L\-U\-S, the scalar is set to (sqrt(u$\ast$u+v$\ast$v)), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-P\-H\-A\-S\-E, the scalar is set to (atan2(v,u)) (in degrees, 0 to 360), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-Q\-U\-A\-D\-R\-A\-N\-T, the scalar is set to 1, 2, 3 or 4 depending upon the quadrant of the point (u,v). S\-C\-A\-L\-A\-R\-\_\-\-X, the scalar is set to the x-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Y, the scalar is set to the y-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Z, the scalar is set to the z-\/value. S\-C\-A\-L\-A\-R\-\_\-\-D\-I\-S\-T\-A\-N\-C\-E, the scalar is set to (sqrt(x$\ast$x+y$\ast$y+z$\ast$z)). I.\-e. distance from the origin. S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D, the scalar is set to the value returned from Evaluate\-Scalar().  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-V (void )} -\/ Get/\-Set the mode used for the scalar data. The options are\-: S\-C\-A\-L\-A\-R\-\_\-\-N\-O\-N\-E, (default) scalars are not generated. S\-C\-A\-L\-A\-R\-\_\-\-U, the scalar is set to the u-\/value. S\-C\-A\-L\-A\-R\-\_\-\-V, the scalar is set to the v-\/value. S\-C\-A\-L\-A\-R\-\_\-\-U0, the scalar is set to 1 if u = (u\-\_\-max -\/ u\-\_\-min)/2 = u\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-V0, the scalar is set to 1 if v = (v\-\_\-max -\/ v\-\_\-min)/2 = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-U0\-V0, the scalar is set to 1 if u == u\-\_\-avg, 2 if v == v\-\_\-avg, 3 if u = u\-\_\-avg \&\& v = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-M\-O\-D\-U\-L\-U\-S, the scalar is set to (sqrt(u$\ast$u+v$\ast$v)), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-P\-H\-A\-S\-E, the scalar is set to (atan2(v,u)) (in degrees, 0 to 360), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-Q\-U\-A\-D\-R\-A\-N\-T, the scalar is set to 1, 2, 3 or 4 depending upon the quadrant of the point (u,v). S\-C\-A\-L\-A\-R\-\_\-\-X, the scalar is set to the x-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Y, the scalar is set to the y-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Z, the scalar is set to the z-\/value. S\-C\-A\-L\-A\-R\-\_\-\-D\-I\-S\-T\-A\-N\-C\-E, the scalar is set to (sqrt(x$\ast$x+y$\ast$y+z$\ast$z)). I.\-e. distance from the origin. S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D, the scalar is set to the value returned from Evaluate\-Scalar().  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-U0 (void )} -\/ Get/\-Set the mode used for the scalar data. The options are\-: S\-C\-A\-L\-A\-R\-\_\-\-N\-O\-N\-E, (default) scalars are not generated. S\-C\-A\-L\-A\-R\-\_\-\-U, the scalar is set to the u-\/value. S\-C\-A\-L\-A\-R\-\_\-\-V, the scalar is set to the v-\/value. S\-C\-A\-L\-A\-R\-\_\-\-U0, the scalar is set to 1 if u = (u\-\_\-max -\/ u\-\_\-min)/2 = u\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-V0, the scalar is set to 1 if v = (v\-\_\-max -\/ v\-\_\-min)/2 = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-U0\-V0, the scalar is set to 1 if u == u\-\_\-avg, 2 if v == v\-\_\-avg, 3 if u = u\-\_\-avg \&\& v = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-M\-O\-D\-U\-L\-U\-S, the scalar is set to (sqrt(u$\ast$u+v$\ast$v)), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-P\-H\-A\-S\-E, the scalar is set to (atan2(v,u)) (in degrees, 0 to 360), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-Q\-U\-A\-D\-R\-A\-N\-T, the scalar is set to 1, 2, 3 or 4 depending upon the quadrant of the point (u,v). S\-C\-A\-L\-A\-R\-\_\-\-X, the scalar is set to the x-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Y, the scalar is set to the y-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Z, the scalar is set to the z-\/value. S\-C\-A\-L\-A\-R\-\_\-\-D\-I\-S\-T\-A\-N\-C\-E, the scalar is set to (sqrt(x$\ast$x+y$\ast$y+z$\ast$z)). I.\-e. distance from the origin. S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D, the scalar is set to the value returned from Evaluate\-Scalar().  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-V0 (void )} -\/ Get/\-Set the mode used for the scalar data. The options are\-: S\-C\-A\-L\-A\-R\-\_\-\-N\-O\-N\-E, (default) scalars are not generated. S\-C\-A\-L\-A\-R\-\_\-\-U, the scalar is set to the u-\/value. S\-C\-A\-L\-A\-R\-\_\-\-V, the scalar is set to the v-\/value. S\-C\-A\-L\-A\-R\-\_\-\-U0, the scalar is set to 1 if u = (u\-\_\-max -\/ u\-\_\-min)/2 = u\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-V0, the scalar is set to 1 if v = (v\-\_\-max -\/ v\-\_\-min)/2 = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-U0\-V0, the scalar is set to 1 if u == u\-\_\-avg, 2 if v == v\-\_\-avg, 3 if u = u\-\_\-avg \&\& v = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-M\-O\-D\-U\-L\-U\-S, the scalar is set to (sqrt(u$\ast$u+v$\ast$v)), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-P\-H\-A\-S\-E, the scalar is set to (atan2(v,u)) (in degrees, 0 to 360), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-Q\-U\-A\-D\-R\-A\-N\-T, the scalar is set to 1, 2, 3 or 4 depending upon the quadrant of the point (u,v). S\-C\-A\-L\-A\-R\-\_\-\-X, the scalar is set to the x-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Y, the scalar is set to the y-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Z, the scalar is set to the z-\/value. S\-C\-A\-L\-A\-R\-\_\-\-D\-I\-S\-T\-A\-N\-C\-E, the scalar is set to (sqrt(x$\ast$x+y$\ast$y+z$\ast$z)). I.\-e. distance from the origin. S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D, the scalar is set to the value returned from Evaluate\-Scalar().  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-U0\-V0 (void )} -\/ Get/\-Set the mode used for the scalar data. The options are\-: S\-C\-A\-L\-A\-R\-\_\-\-N\-O\-N\-E, (default) scalars are not generated. S\-C\-A\-L\-A\-R\-\_\-\-U, the scalar is set to the u-\/value. S\-C\-A\-L\-A\-R\-\_\-\-V, the scalar is set to the v-\/value. S\-C\-A\-L\-A\-R\-\_\-\-U0, the scalar is set to 1 if u = (u\-\_\-max -\/ u\-\_\-min)/2 = u\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-V0, the scalar is set to 1 if v = (v\-\_\-max -\/ v\-\_\-min)/2 = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-U0\-V0, the scalar is set to 1 if u == u\-\_\-avg, 2 if v == v\-\_\-avg, 3 if u = u\-\_\-avg \&\& v = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-M\-O\-D\-U\-L\-U\-S, the scalar is set to (sqrt(u$\ast$u+v$\ast$v)), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-P\-H\-A\-S\-E, the scalar is set to (atan2(v,u)) (in degrees, 0 to 360), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-Q\-U\-A\-D\-R\-A\-N\-T, the scalar is set to 1, 2, 3 or 4 depending upon the quadrant of the point (u,v). S\-C\-A\-L\-A\-R\-\_\-\-X, the scalar is set to the x-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Y, the scalar is set to the y-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Z, the scalar is set to the z-\/value. S\-C\-A\-L\-A\-R\-\_\-\-D\-I\-S\-T\-A\-N\-C\-E, the scalar is set to (sqrt(x$\ast$x+y$\ast$y+z$\ast$z)). I.\-e. distance from the origin. S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D, the scalar is set to the value returned from Evaluate\-Scalar().  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Modulus (void )} -\/ Get/\-Set the mode used for the scalar data. The options are\-: S\-C\-A\-L\-A\-R\-\_\-\-N\-O\-N\-E, (default) scalars are not generated. S\-C\-A\-L\-A\-R\-\_\-\-U, the scalar is set to the u-\/value. S\-C\-A\-L\-A\-R\-\_\-\-V, the scalar is set to the v-\/value. S\-C\-A\-L\-A\-R\-\_\-\-U0, the scalar is set to 1 if u = (u\-\_\-max -\/ u\-\_\-min)/2 = u\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-V0, the scalar is set to 1 if v = (v\-\_\-max -\/ v\-\_\-min)/2 = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-U0\-V0, the scalar is set to 1 if u == u\-\_\-avg, 2 if v == v\-\_\-avg, 3 if u = u\-\_\-avg \&\& v = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-M\-O\-D\-U\-L\-U\-S, the scalar is set to (sqrt(u$\ast$u+v$\ast$v)), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-P\-H\-A\-S\-E, the scalar is set to (atan2(v,u)) (in degrees, 0 to 360), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-Q\-U\-A\-D\-R\-A\-N\-T, the scalar is set to 1, 2, 3 or 4 depending upon the quadrant of the point (u,v). S\-C\-A\-L\-A\-R\-\_\-\-X, the scalar is set to the x-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Y, the scalar is set to the y-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Z, the scalar is set to the z-\/value. S\-C\-A\-L\-A\-R\-\_\-\-D\-I\-S\-T\-A\-N\-C\-E, the scalar is set to (sqrt(x$\ast$x+y$\ast$y+z$\ast$z)). I.\-e. distance from the origin. S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D, the scalar is set to the value returned from Evaluate\-Scalar().  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Phase (void )} -\/ Get/\-Set the mode used for the scalar data. The options are\-: S\-C\-A\-L\-A\-R\-\_\-\-N\-O\-N\-E, (default) scalars are not generated. S\-C\-A\-L\-A\-R\-\_\-\-U, the scalar is set to the u-\/value. S\-C\-A\-L\-A\-R\-\_\-\-V, the scalar is set to the v-\/value. S\-C\-A\-L\-A\-R\-\_\-\-U0, the scalar is set to 1 if u = (u\-\_\-max -\/ u\-\_\-min)/2 = u\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-V0, the scalar is set to 1 if v = (v\-\_\-max -\/ v\-\_\-min)/2 = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-U0\-V0, the scalar is set to 1 if u == u\-\_\-avg, 2 if v == v\-\_\-avg, 3 if u = u\-\_\-avg \&\& v = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-M\-O\-D\-U\-L\-U\-S, the scalar is set to (sqrt(u$\ast$u+v$\ast$v)), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-P\-H\-A\-S\-E, the scalar is set to (atan2(v,u)) (in degrees, 0 to 360), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-Q\-U\-A\-D\-R\-A\-N\-T, the scalar is set to 1, 2, 3 or 4 depending upon the quadrant of the point (u,v). S\-C\-A\-L\-A\-R\-\_\-\-X, the scalar is set to the x-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Y, the scalar is set to the y-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Z, the scalar is set to the z-\/value. S\-C\-A\-L\-A\-R\-\_\-\-D\-I\-S\-T\-A\-N\-C\-E, the scalar is set to (sqrt(x$\ast$x+y$\ast$y+z$\ast$z)). I.\-e. distance from the origin. S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D, the scalar is set to the value returned from Evaluate\-Scalar().  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Quadrant (void )} -\/ Get/\-Set the mode used for the scalar data. The options are\-: S\-C\-A\-L\-A\-R\-\_\-\-N\-O\-N\-E, (default) scalars are not generated. S\-C\-A\-L\-A\-R\-\_\-\-U, the scalar is set to the u-\/value. S\-C\-A\-L\-A\-R\-\_\-\-V, the scalar is set to the v-\/value. S\-C\-A\-L\-A\-R\-\_\-\-U0, the scalar is set to 1 if u = (u\-\_\-max -\/ u\-\_\-min)/2 = u\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-V0, the scalar is set to 1 if v = (v\-\_\-max -\/ v\-\_\-min)/2 = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-U0\-V0, the scalar is set to 1 if u == u\-\_\-avg, 2 if v == v\-\_\-avg, 3 if u = u\-\_\-avg \&\& v = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-M\-O\-D\-U\-L\-U\-S, the scalar is set to (sqrt(u$\ast$u+v$\ast$v)), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-P\-H\-A\-S\-E, the scalar is set to (atan2(v,u)) (in degrees, 0 to 360), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-Q\-U\-A\-D\-R\-A\-N\-T, the scalar is set to 1, 2, 3 or 4 depending upon the quadrant of the point (u,v). S\-C\-A\-L\-A\-R\-\_\-\-X, the scalar is set to the x-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Y, the scalar is set to the y-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Z, the scalar is set to the z-\/value. S\-C\-A\-L\-A\-R\-\_\-\-D\-I\-S\-T\-A\-N\-C\-E, the scalar is set to (sqrt(x$\ast$x+y$\ast$y+z$\ast$z)). I.\-e. distance from the origin. S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D, the scalar is set to the value returned from Evaluate\-Scalar().  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-X (void )} -\/ Get/\-Set the mode used for the scalar data. The options are\-: S\-C\-A\-L\-A\-R\-\_\-\-N\-O\-N\-E, (default) scalars are not generated. S\-C\-A\-L\-A\-R\-\_\-\-U, the scalar is set to the u-\/value. S\-C\-A\-L\-A\-R\-\_\-\-V, the scalar is set to the v-\/value. S\-C\-A\-L\-A\-R\-\_\-\-U0, the scalar is set to 1 if u = (u\-\_\-max -\/ u\-\_\-min)/2 = u\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-V0, the scalar is set to 1 if v = (v\-\_\-max -\/ v\-\_\-min)/2 = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-U0\-V0, the scalar is set to 1 if u == u\-\_\-avg, 2 if v == v\-\_\-avg, 3 if u = u\-\_\-avg \&\& v = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-M\-O\-D\-U\-L\-U\-S, the scalar is set to (sqrt(u$\ast$u+v$\ast$v)), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-P\-H\-A\-S\-E, the scalar is set to (atan2(v,u)) (in degrees, 0 to 360), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-Q\-U\-A\-D\-R\-A\-N\-T, the scalar is set to 1, 2, 3 or 4 depending upon the quadrant of the point (u,v). S\-C\-A\-L\-A\-R\-\_\-\-X, the scalar is set to the x-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Y, the scalar is set to the y-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Z, the scalar is set to the z-\/value. S\-C\-A\-L\-A\-R\-\_\-\-D\-I\-S\-T\-A\-N\-C\-E, the scalar is set to (sqrt(x$\ast$x+y$\ast$y+z$\ast$z)). I.\-e. distance from the origin. S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D, the scalar is set to the value returned from Evaluate\-Scalar().  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Y (void )} -\/ Get/\-Set the mode used for the scalar data. The options are\-: S\-C\-A\-L\-A\-R\-\_\-\-N\-O\-N\-E, (default) scalars are not generated. S\-C\-A\-L\-A\-R\-\_\-\-U, the scalar is set to the u-\/value. S\-C\-A\-L\-A\-R\-\_\-\-V, the scalar is set to the v-\/value. S\-C\-A\-L\-A\-R\-\_\-\-U0, the scalar is set to 1 if u = (u\-\_\-max -\/ u\-\_\-min)/2 = u\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-V0, the scalar is set to 1 if v = (v\-\_\-max -\/ v\-\_\-min)/2 = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-U0\-V0, the scalar is set to 1 if u == u\-\_\-avg, 2 if v == v\-\_\-avg, 3 if u = u\-\_\-avg \&\& v = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-M\-O\-D\-U\-L\-U\-S, the scalar is set to (sqrt(u$\ast$u+v$\ast$v)), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-P\-H\-A\-S\-E, the scalar is set to (atan2(v,u)) (in degrees, 0 to 360), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-Q\-U\-A\-D\-R\-A\-N\-T, the scalar is set to 1, 2, 3 or 4 depending upon the quadrant of the point (u,v). S\-C\-A\-L\-A\-R\-\_\-\-X, the scalar is set to the x-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Y, the scalar is set to the y-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Z, the scalar is set to the z-\/value. S\-C\-A\-L\-A\-R\-\_\-\-D\-I\-S\-T\-A\-N\-C\-E, the scalar is set to (sqrt(x$\ast$x+y$\ast$y+z$\ast$z)). I.\-e. distance from the origin. S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D, the scalar is set to the value returned from Evaluate\-Scalar().  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Z (void )} -\/ Get/\-Set the mode used for the scalar data. The options are\-: S\-C\-A\-L\-A\-R\-\_\-\-N\-O\-N\-E, (default) scalars are not generated. S\-C\-A\-L\-A\-R\-\_\-\-U, the scalar is set to the u-\/value. S\-C\-A\-L\-A\-R\-\_\-\-V, the scalar is set to the v-\/value. S\-C\-A\-L\-A\-R\-\_\-\-U0, the scalar is set to 1 if u = (u\-\_\-max -\/ u\-\_\-min)/2 = u\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-V0, the scalar is set to 1 if v = (v\-\_\-max -\/ v\-\_\-min)/2 = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-U0\-V0, the scalar is set to 1 if u == u\-\_\-avg, 2 if v == v\-\_\-avg, 3 if u = u\-\_\-avg \&\& v = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-M\-O\-D\-U\-L\-U\-S, the scalar is set to (sqrt(u$\ast$u+v$\ast$v)), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-P\-H\-A\-S\-E, the scalar is set to (atan2(v,u)) (in degrees, 0 to 360), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-Q\-U\-A\-D\-R\-A\-N\-T, the scalar is set to 1, 2, 3 or 4 depending upon the quadrant of the point (u,v). S\-C\-A\-L\-A\-R\-\_\-\-X, the scalar is set to the x-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Y, the scalar is set to the y-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Z, the scalar is set to the z-\/value. S\-C\-A\-L\-A\-R\-\_\-\-D\-I\-S\-T\-A\-N\-C\-E, the scalar is set to (sqrt(x$\ast$x+y$\ast$y+z$\ast$z)). I.\-e. distance from the origin. S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D, the scalar is set to the value returned from Evaluate\-Scalar().  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Distance (void )} -\/ Get/\-Set the mode used for the scalar data. The options are\-: S\-C\-A\-L\-A\-R\-\_\-\-N\-O\-N\-E, (default) scalars are not generated. S\-C\-A\-L\-A\-R\-\_\-\-U, the scalar is set to the u-\/value. S\-C\-A\-L\-A\-R\-\_\-\-V, the scalar is set to the v-\/value. S\-C\-A\-L\-A\-R\-\_\-\-U0, the scalar is set to 1 if u = (u\-\_\-max -\/ u\-\_\-min)/2 = u\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-V0, the scalar is set to 1 if v = (v\-\_\-max -\/ v\-\_\-min)/2 = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-U0\-V0, the scalar is set to 1 if u == u\-\_\-avg, 2 if v == v\-\_\-avg, 3 if u = u\-\_\-avg \&\& v = v\-\_\-avg, 0 otherwise. S\-C\-A\-L\-A\-R\-\_\-\-M\-O\-D\-U\-L\-U\-S, the scalar is set to (sqrt(u$\ast$u+v$\ast$v)), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-P\-H\-A\-S\-E, the scalar is set to (atan2(v,u)) (in degrees, 0 to 360), this is measured relative to (u\-\_\-avg,v\-\_\-avg). S\-C\-A\-L\-A\-R\-\_\-\-Q\-U\-A\-D\-R\-A\-N\-T, the scalar is set to 1, 2, 3 or 4 depending upon the quadrant of the point (u,v). S\-C\-A\-L\-A\-R\-\_\-\-X, the scalar is set to the x-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Y, the scalar is set to the y-\/value. S\-C\-A\-L\-A\-R\-\_\-\-Z, the scalar is set to the z-\/value. S\-C\-A\-L\-A\-R\-\_\-\-D\-I\-S\-T\-A\-N\-C\-E, the scalar is set to (sqrt(x$\ast$x+y$\ast$y+z$\ast$z)). I.\-e. distance from the origin. S\-C\-A\-L\-A\-R\-\_\-\-F\-U\-N\-C\-T\-I\-O\-N\-\_\-\-D\-E\-F\-I\-N\-E\-D, the scalar is set to the value returned from Evaluate\-Scalar().  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Function\-Defined (void )} -\/ Return the M\-Time also considering the parametric function.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return the M\-Time also considering the parametric function.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkplanesource}{}\section{vtk\-Plane\-Source}\label{vtkgraphics_vtkplanesource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Plane\-Source creates an m x n array of quadrilaterals arranged as a regular tiling in a plane. The plane is defined by specifying an origin point, and then two other points that, together with the origin, define two axes for the plane. These axes do not have to be orthogonal -\/ so you can create a parallelogram. (The axes must not be parallel.) The resolution of the plane (i.\-e., number of subdivisions) is controlled by the ivars X\-Resolution and Y\-Resolution.

By default, the plane is centered at the origin and perpendicular to the z-\/axis, with width and height of length 1 and resolutions set to 1.

There are three convenience methods that allow you to easily move the plane. The first, Set\-Normal(), allows you to specify the plane normal. The effect of this method is to rotate the plane around the center of the plane, aligning the plane normal with the specified normal. The rotation is about the axis defined by the cross product of the current normal with the new normal. The second, Set\-Center(), translates the center of the plane to the specified center point. The third method, Push(), allows you to translate the plane along the plane normal by the distance specified. (Negative Push values translate the plane in the negative normal direction.) Note that the Set\-Normal(), Set\-Center() and Push() methods modify the Origin, Point1, and/or Point2 instance variables.

To create an instance of class vtk\-Plane\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPlaneSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Plane\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Plane\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Plane\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Plane\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-X\-Resolution (int )} -\/ Specify the resolution of the plane along the first axes.  
\item {\ttfamily int = obj.\-Get\-X\-Resolution ()} -\/ Specify the resolution of the plane along the first axes.  
\item {\ttfamily obj.\-Set\-Y\-Resolution (int )} -\/ Specify the resolution of the plane along the second axes.  
\item {\ttfamily int = obj.\-Get\-Y\-Resolution ()} -\/ Specify the resolution of the plane along the second axes.  
\item {\ttfamily obj.\-Set\-Resolution (int x\-R, int y\-R)} -\/ Set the number of x-\/y subdivisions in the plane.  
\item {\ttfamily obj.\-Set\-Origin (double , double , double )} -\/ Specify a point defining the origin of the plane.  
\item {\ttfamily obj.\-Set\-Origin (double a\mbox{[}3\mbox{]})} -\/ Specify a point defining the origin of the plane.  
\item {\ttfamily double = obj. Get\-Origin ()} -\/ Specify a point defining the origin of the plane.  
\item {\ttfamily obj.\-Set\-Point1 (double x, double y, double z)} -\/ Specify a point defining the first axis of the plane.  
\item {\ttfamily obj.\-Set\-Point1 (double pnt\mbox{[}3\mbox{]})} -\/ Specify a point defining the first axis of the plane.  
\item {\ttfamily double = obj. Get\-Point1 ()} -\/ Specify a point defining the first axis of the plane.  
\item {\ttfamily obj.\-Set\-Point2 (double x, double y, double z)} -\/ Specify a point defining the second axis of the plane.  
\item {\ttfamily obj.\-Set\-Point2 (double pnt\mbox{[}3\mbox{]})} -\/ Specify a point defining the second axis of the plane.  
\item {\ttfamily double = obj. Get\-Point2 ()} -\/ Specify a point defining the second axis of the plane.  
\item {\ttfamily obj.\-Set\-Center (double x, double y, double z)} -\/ Set/\-Get the center of the plane. Works in conjunction with the plane normal to position the plane. Don't use this method to define the plane. Instead, use it to move the plane to a new center point.  
\item {\ttfamily obj.\-Set\-Center (double center\mbox{[}3\mbox{]})} -\/ Set/\-Get the center of the plane. Works in conjunction with the plane normal to position the plane. Don't use this method to define the plane. Instead, use it to move the plane to a new center point.  
\item {\ttfamily double = obj. Get\-Center ()} -\/ Set/\-Get the center of the plane. Works in conjunction with the plane normal to position the plane. Don't use this method to define the plane. Instead, use it to move the plane to a new center point.  
\item {\ttfamily obj.\-Set\-Normal (double nx, double ny, double nz)} -\/ Set/\-Get the plane normal. Works in conjunction with the plane center to orient the plane. Don't use this method to define the plane. Instead, use it to rotate the plane around the current center point.  
\item {\ttfamily obj.\-Set\-Normal (double n\mbox{[}3\mbox{]})} -\/ Set/\-Get the plane normal. Works in conjunction with the plane center to orient the plane. Don't use this method to define the plane. Instead, use it to rotate the plane around the current center point.  
\item {\ttfamily double = obj. Get\-Normal ()} -\/ Set/\-Get the plane normal. Works in conjunction with the plane center to orient the plane. Don't use this method to define the plane. Instead, use it to rotate the plane around the current center point.  
\item {\ttfamily obj.\-Push (double distance)} -\/ Translate the plane in the direction of the normal by the distance specified. Negative values move the plane in the opposite direction.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkplatonicsolidsource}{}\section{vtk\-Platonic\-Solid\-Source}\label{vtkgraphics_vtkplatonicsolidsource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Platonic\-Solid\-Source can generate each of the five Platonic solids\-: tetrahedron, cube, octahedron, icosahedron, and dodecahedron. Each of the solids is placed inside a sphere centered at the origin with radius 1.\-0. To use this class, simply specify the solid to create. Note that this source object creates cell scalars that are (integral value) face numbers.

To create an instance of class vtk\-Platonic\-Solid\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPlatonicSolidSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Platonic\-Solid\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Platonic\-Solid\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Platonic\-Solid\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Platonic\-Solid\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Solid\-Type (int )} -\/ Specify the type of Platonic\-Solid solid to create.  
\item {\ttfamily int = obj.\-Get\-Solid\-Type\-Min\-Value ()} -\/ Specify the type of Platonic\-Solid solid to create.  
\item {\ttfamily int = obj.\-Get\-Solid\-Type\-Max\-Value ()} -\/ Specify the type of Platonic\-Solid solid to create.  
\item {\ttfamily int = obj.\-Get\-Solid\-Type ()} -\/ Specify the type of Platonic\-Solid solid to create.  
\item {\ttfamily obj.\-Set\-Solid\-Type\-To\-Tetrahedron ()} -\/ Specify the type of Platonic\-Solid solid to create.  
\item {\ttfamily obj.\-Set\-Solid\-Type\-To\-Cube ()} -\/ Specify the type of Platonic\-Solid solid to create.  
\item {\ttfamily obj.\-Set\-Solid\-Type\-To\-Octahedron ()} -\/ Specify the type of Platonic\-Solid solid to create.  
\item {\ttfamily obj.\-Set\-Solid\-Type\-To\-Icosahedron ()} -\/ Specify the type of Platonic\-Solid solid to create.  
\item {\ttfamily obj.\-Set\-Solid\-Type\-To\-Dodecahedron ()}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkpointdatatocelldata}{}\section{vtk\-Point\-Data\-To\-Cell\-Data}\label{vtkgraphics_vtkpointdatatocelldata}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Point\-Data\-To\-Cell\-Data is a filter that transforms point data (i.\-e., data specified per point) into cell data (i.\-e., data specified per cell). The method of transformation is based on averaging the data values of all points defining a particular cell. Optionally, the input point data can be passed through to the output as well.

To create an instance of class vtk\-Point\-Data\-To\-Cell\-Data, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPointDataToCellData
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Point\-Data\-To\-Cell\-Data has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Point\-Data\-To\-Cell\-Data class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Point\-Data\-To\-Cell\-Data = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Point\-Data\-To\-Cell\-Data = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Pass\-Point\-Data (int )} -\/ Control whether the input point data is to be passed to the output. If on, then the input point data is passed through to the output; otherwise, only generated point data is placed into the output.  
\item {\ttfamily int = obj.\-Get\-Pass\-Point\-Data ()} -\/ Control whether the input point data is to be passed to the output. If on, then the input point data is passed through to the output; otherwise, only generated point data is placed into the output.  
\item {\ttfamily obj.\-Pass\-Point\-Data\-On ()} -\/ Control whether the input point data is to be passed to the output. If on, then the input point data is passed through to the output; otherwise, only generated point data is placed into the output.  
\item {\ttfamily obj.\-Pass\-Point\-Data\-Off ()} -\/ Control whether the input point data is to be passed to the output. If on, then the input point data is passed through to the output; otherwise, only generated point data is placed into the output.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkpointsource}{}\section{vtk\-Point\-Source}\label{vtkgraphics_vtkpointsource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Point\-Source is a source object that creates a user-\/specified number of points within a specified radius about a specified center point. By default location of the points is random within the sphere. It is also possible to generate random points only on the surface of the sphere.

To create an instance of class vtk\-Point\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPointSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Point\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Point\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Point\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Point\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Number\-Of\-Points (vtk\-Id\-Type )} -\/ Set the number of points to generate.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Points\-Min\-Value ()} -\/ Set the number of points to generate.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Points\-Max\-Value ()} -\/ Set the number of points to generate.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Points ()} -\/ Set the number of points to generate.  
\item {\ttfamily obj.\-Set\-Center (double , double , double )} -\/ Set the center of the point cloud.  
\item {\ttfamily obj.\-Set\-Center (double a\mbox{[}3\mbox{]})} -\/ Set the center of the point cloud.  
\item {\ttfamily double = obj. Get\-Center ()} -\/ Set the center of the point cloud.  
\item {\ttfamily obj.\-Set\-Radius (double )} -\/ Set the radius of the point cloud. If you are generating a Gaussian distribution, then this is the standard deviation for each of x, y, and z.  
\item {\ttfamily double = obj.\-Get\-Radius\-Min\-Value ()} -\/ Set the radius of the point cloud. If you are generating a Gaussian distribution, then this is the standard deviation for each of x, y, and z.  
\item {\ttfamily double = obj.\-Get\-Radius\-Max\-Value ()} -\/ Set the radius of the point cloud. If you are generating a Gaussian distribution, then this is the standard deviation for each of x, y, and z.  
\item {\ttfamily double = obj.\-Get\-Radius ()} -\/ Set the radius of the point cloud. If you are generating a Gaussian distribution, then this is the standard deviation for each of x, y, and z.  
\item {\ttfamily obj.\-Set\-Distribution (int )} -\/ Specify the distribution to use. The default is a uniform distribution. The shell distribution produces random points on the surface of the sphere, none in the interior.  
\item {\ttfamily obj.\-Set\-Distribution\-To\-Uniform ()} -\/ Specify the distribution to use. The default is a uniform distribution. The shell distribution produces random points on the surface of the sphere, none in the interior.  
\item {\ttfamily obj.\-Set\-Distribution\-To\-Shell ()} -\/ Specify the distribution to use. The default is a uniform distribution. The shell distribution produces random points on the surface of the sphere, none in the interior.  
\item {\ttfamily int = obj.\-Get\-Distribution ()} -\/ Specify the distribution to use. The default is a uniform distribution. The shell distribution produces random points on the surface of the sphere, none in the interior.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkpolydataconnectivityfilter}{}\section{vtk\-Poly\-Data\-Connectivity\-Filter}\label{vtkgraphics_vtkpolydataconnectivityfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Poly\-Data\-Connectivity\-Filter is a filter that extracts cells that share common points and/or satisfy a scalar threshold criterion. (Such a group of cells is called a region.) The filter works in one of six ways\-: 1) extract the largest connected region in the dataset; 2) extract specified region numbers; 3) extract all regions sharing specified point ids; 4) extract all regions sharing specified cell ids; 5) extract the region closest to the specified point; or 6) extract all regions (used to color regions).

This filter is specialized for polygonal data. This means it runs a bit faster and is easier to construct visualization networks that process polygonal data.

The behavior of vtk\-Poly\-Data\-Connectivity\-Filter can be modified by turning on the boolean ivar Scalar\-Connectivity. If this flag is on, the connectivity algorithm is modified so that cells are considered connected only if 1) they are geometrically connected (share a point) and 2) the scalar values of one of the cell's points falls in the scalar range specified. This use of Scalar\-Connectivity is particularly useful for selecting cells for later processing.

To create an instance of class vtk\-Poly\-Data\-Connectivity\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPolyDataConnectivityFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Poly\-Data\-Connectivity\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Connectivity\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Poly\-Data\-Connectivity\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Poly\-Data\-Connectivity\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Scalar\-Connectivity (int )} -\/ Turn on/off connectivity based on scalar value. If on, cells are connected only if they share points A\-N\-D one of the cells scalar values falls in the scalar range specified.  
\item {\ttfamily int = obj.\-Get\-Scalar\-Connectivity ()} -\/ Turn on/off connectivity based on scalar value. If on, cells are connected only if they share points A\-N\-D one of the cells scalar values falls in the scalar range specified.  
\item {\ttfamily obj.\-Scalar\-Connectivity\-On ()} -\/ Turn on/off connectivity based on scalar value. If on, cells are connected only if they share points A\-N\-D one of the cells scalar values falls in the scalar range specified.  
\item {\ttfamily obj.\-Scalar\-Connectivity\-Off ()} -\/ Turn on/off connectivity based on scalar value. If on, cells are connected only if they share points A\-N\-D one of the cells scalar values falls in the scalar range specified.  
\item {\ttfamily obj.\-Set\-Scalar\-Range (double , double )} -\/ Set the scalar range to use to extract cells based on scalar connectivity.  
\item {\ttfamily obj.\-Set\-Scalar\-Range (double a\mbox{[}2\mbox{]})} -\/ Set the scalar range to use to extract cells based on scalar connectivity.  
\item {\ttfamily double = obj. Get\-Scalar\-Range ()} -\/ Set the scalar range to use to extract cells based on scalar connectivity.  
\item {\ttfamily obj.\-Set\-Extraction\-Mode (int )} -\/ Control the extraction of connected surfaces.  
\item {\ttfamily int = obj.\-Get\-Extraction\-Mode\-Min\-Value ()} -\/ Control the extraction of connected surfaces.  
\item {\ttfamily int = obj.\-Get\-Extraction\-Mode\-Max\-Value ()} -\/ Control the extraction of connected surfaces.  
\item {\ttfamily int = obj.\-Get\-Extraction\-Mode ()} -\/ Control the extraction of connected surfaces.  
\item {\ttfamily obj.\-Set\-Extraction\-Mode\-To\-Point\-Seeded\-Regions ()} -\/ Control the extraction of connected surfaces.  
\item {\ttfamily obj.\-Set\-Extraction\-Mode\-To\-Cell\-Seeded\-Regions ()} -\/ Control the extraction of connected surfaces.  
\item {\ttfamily obj.\-Set\-Extraction\-Mode\-To\-Largest\-Region ()} -\/ Control the extraction of connected surfaces.  
\item {\ttfamily obj.\-Set\-Extraction\-Mode\-To\-Specified\-Regions ()} -\/ Control the extraction of connected surfaces.  
\item {\ttfamily obj.\-Set\-Extraction\-Mode\-To\-Closest\-Point\-Region ()} -\/ Control the extraction of connected surfaces.  
\item {\ttfamily obj.\-Set\-Extraction\-Mode\-To\-All\-Regions ()} -\/ Control the extraction of connected surfaces.  
\item {\ttfamily string = obj.\-Get\-Extraction\-Mode\-As\-String ()} -\/ Control the extraction of connected surfaces.  
\item {\ttfamily obj.\-Initialize\-Seed\-List ()} -\/ Initialize list of point ids/cell ids used to seed regions.  
\item {\ttfamily obj.\-Add\-Seed (int id)} -\/ Add a seed id (point or cell id). Note\-: ids are 0-\/offset.  
\item {\ttfamily obj.\-Delete\-Seed (int id)} -\/ Delete a seed id (point or cell id). Note\-: ids are 0-\/offset.  
\item {\ttfamily obj.\-Initialize\-Specified\-Region\-List ()} -\/ Initialize list of region ids to extract.  
\item {\ttfamily obj.\-Add\-Specified\-Region (int id)} -\/ Add a region id to extract. Note\-: ids are 0-\/offset.  
\item {\ttfamily obj.\-Delete\-Specified\-Region (int id)} -\/ Delete a region id to extract. Note\-: ids are 0-\/offset.  
\item {\ttfamily obj.\-Set\-Closest\-Point (double , double , double )} -\/ Use to specify x-\/y-\/z point coordinates when extracting the region closest to a specified point.  
\item {\ttfamily obj.\-Set\-Closest\-Point (double a\mbox{[}3\mbox{]})} -\/ Use to specify x-\/y-\/z point coordinates when extracting the region closest to a specified point.  
\item {\ttfamily double = obj. Get\-Closest\-Point ()} -\/ Use to specify x-\/y-\/z point coordinates when extracting the region closest to a specified point.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Extracted\-Regions ()} -\/ Obtain the number of connected regions.  
\item {\ttfamily obj.\-Set\-Color\-Regions (int )} -\/ Turn on/off the coloring of connected regions.  
\item {\ttfamily int = obj.\-Get\-Color\-Regions ()} -\/ Turn on/off the coloring of connected regions.  
\item {\ttfamily obj.\-Color\-Regions\-On ()} -\/ Turn on/off the coloring of connected regions.  
\item {\ttfamily obj.\-Color\-Regions\-Off ()} -\/ Turn on/off the coloring of connected regions.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkpolydatanormals}{}\section{vtk\-Poly\-Data\-Normals}\label{vtkgraphics_vtkpolydatanormals}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Poly\-Data\-Normals is a filter that computes point normals for a polygonal mesh. The filter can reorder polygons to insure consistent orientation across polygon neighbors. Sharp edges can be split and points duplicated with separate normals to give crisp (rendered) surface definition. It is also possible to globally flip the normal orientation.

The algorithm works by determining normals for each polygon and then averaging them at shared points. When sharp edges are present, the edges are split and new points generated to prevent blurry edges (due to Gouraud shading).

To create an instance of class vtk\-Poly\-Data\-Normals, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPolyDataNormals
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Poly\-Data\-Normals has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Normals class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Poly\-Data\-Normals = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Poly\-Data\-Normals = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Feature\-Angle (double )} -\/ Specify the angle that defines a sharp edge. If the difference in angle across neighboring polygons is greater than this value, the shared edge is considered \char`\"{}sharp\char`\"{}.  
\item {\ttfamily double = obj.\-Get\-Feature\-Angle\-Min\-Value ()} -\/ Specify the angle that defines a sharp edge. If the difference in angle across neighboring polygons is greater than this value, the shared edge is considered \char`\"{}sharp\char`\"{}.  
\item {\ttfamily double = obj.\-Get\-Feature\-Angle\-Max\-Value ()} -\/ Specify the angle that defines a sharp edge. If the difference in angle across neighboring polygons is greater than this value, the shared edge is considered \char`\"{}sharp\char`\"{}.  
\item {\ttfamily double = obj.\-Get\-Feature\-Angle ()} -\/ Specify the angle that defines a sharp edge. If the difference in angle across neighboring polygons is greater than this value, the shared edge is considered \char`\"{}sharp\char`\"{}.  
\item {\ttfamily obj.\-Set\-Splitting (int )} -\/ Turn on/off the splitting of sharp edges.  
\item {\ttfamily int = obj.\-Get\-Splitting ()} -\/ Turn on/off the splitting of sharp edges.  
\item {\ttfamily obj.\-Splitting\-On ()} -\/ Turn on/off the splitting of sharp edges.  
\item {\ttfamily obj.\-Splitting\-Off ()} -\/ Turn on/off the splitting of sharp edges.  
\item {\ttfamily obj.\-Set\-Consistency (int )} -\/ Turn on/off the enforcement of consistent polygon ordering.  
\item {\ttfamily int = obj.\-Get\-Consistency ()} -\/ Turn on/off the enforcement of consistent polygon ordering.  
\item {\ttfamily obj.\-Consistency\-On ()} -\/ Turn on/off the enforcement of consistent polygon ordering.  
\item {\ttfamily obj.\-Consistency\-Off ()} -\/ Turn on/off the enforcement of consistent polygon ordering.  
\item {\ttfamily obj.\-Set\-Auto\-Orient\-Normals (int )} -\/ Turn on/off the automatic determination of correct normal orientation. N\-O\-T\-E\-: This assumes a completely closed surface (i.\-e. no boundary edges) and no non-\/manifold edges. If these constraints do not hold, all bets are off. This option adds some computational complexity, and is useful if you don't want to have to inspect the rendered image to determine whether to turn on the Flip\-Normals flag. However, this flag can work with the Flip\-Normals flag, and if both are set, all the normals in the output will point \char`\"{}inward\char`\"{}.  
\item {\ttfamily int = obj.\-Get\-Auto\-Orient\-Normals ()} -\/ Turn on/off the automatic determination of correct normal orientation. N\-O\-T\-E\-: This assumes a completely closed surface (i.\-e. no boundary edges) and no non-\/manifold edges. If these constraints do not hold, all bets are off. This option adds some computational complexity, and is useful if you don't want to have to inspect the rendered image to determine whether to turn on the Flip\-Normals flag. However, this flag can work with the Flip\-Normals flag, and if both are set, all the normals in the output will point \char`\"{}inward\char`\"{}.  
\item {\ttfamily obj.\-Auto\-Orient\-Normals\-On ()} -\/ Turn on/off the automatic determination of correct normal orientation. N\-O\-T\-E\-: This assumes a completely closed surface (i.\-e. no boundary edges) and no non-\/manifold edges. If these constraints do not hold, all bets are off. This option adds some computational complexity, and is useful if you don't want to have to inspect the rendered image to determine whether to turn on the Flip\-Normals flag. However, this flag can work with the Flip\-Normals flag, and if both are set, all the normals in the output will point \char`\"{}inward\char`\"{}.  
\item {\ttfamily obj.\-Auto\-Orient\-Normals\-Off ()} -\/ Turn on/off the automatic determination of correct normal orientation. N\-O\-T\-E\-: This assumes a completely closed surface (i.\-e. no boundary edges) and no non-\/manifold edges. If these constraints do not hold, all bets are off. This option adds some computational complexity, and is useful if you don't want to have to inspect the rendered image to determine whether to turn on the Flip\-Normals flag. However, this flag can work with the Flip\-Normals flag, and if both are set, all the normals in the output will point \char`\"{}inward\char`\"{}.  
\item {\ttfamily obj.\-Set\-Compute\-Point\-Normals (int )} -\/ Turn on/off the computation of point normals.  
\item {\ttfamily int = obj.\-Get\-Compute\-Point\-Normals ()} -\/ Turn on/off the computation of point normals.  
\item {\ttfamily obj.\-Compute\-Point\-Normals\-On ()} -\/ Turn on/off the computation of point normals.  
\item {\ttfamily obj.\-Compute\-Point\-Normals\-Off ()} -\/ Turn on/off the computation of point normals.  
\item {\ttfamily obj.\-Set\-Compute\-Cell\-Normals (int )} -\/ Turn on/off the computation of cell normals.  
\item {\ttfamily int = obj.\-Get\-Compute\-Cell\-Normals ()} -\/ Turn on/off the computation of cell normals.  
\item {\ttfamily obj.\-Compute\-Cell\-Normals\-On ()} -\/ Turn on/off the computation of cell normals.  
\item {\ttfamily obj.\-Compute\-Cell\-Normals\-Off ()} -\/ Turn on/off the computation of cell normals.  
\item {\ttfamily obj.\-Set\-Flip\-Normals (int )} -\/ Turn on/off the global flipping of normal orientation. Flipping reverves the meaning of front and back for Frontface and Backface culling in vtk\-Property. Flipping modifies both the normal direction and the order of a cell's points.  
\item {\ttfamily int = obj.\-Get\-Flip\-Normals ()} -\/ Turn on/off the global flipping of normal orientation. Flipping reverves the meaning of front and back for Frontface and Backface culling in vtk\-Property. Flipping modifies both the normal direction and the order of a cell's points.  
\item {\ttfamily obj.\-Flip\-Normals\-On ()} -\/ Turn on/off the global flipping of normal orientation. Flipping reverves the meaning of front and back for Frontface and Backface culling in vtk\-Property. Flipping modifies both the normal direction and the order of a cell's points.  
\item {\ttfamily obj.\-Flip\-Normals\-Off ()} -\/ Turn on/off the global flipping of normal orientation. Flipping reverves the meaning of front and back for Frontface and Backface culling in vtk\-Property. Flipping modifies both the normal direction and the order of a cell's points.  
\item {\ttfamily obj.\-Set\-Non\-Manifold\-Traversal (int )} -\/ Turn on/off traversal across non-\/manifold edges. This will prevent problems where the consistency of polygonal ordering is corrupted due to topological loops.  
\item {\ttfamily int = obj.\-Get\-Non\-Manifold\-Traversal ()} -\/ Turn on/off traversal across non-\/manifold edges. This will prevent problems where the consistency of polygonal ordering is corrupted due to topological loops.  
\item {\ttfamily obj.\-Non\-Manifold\-Traversal\-On ()} -\/ Turn on/off traversal across non-\/manifold edges. This will prevent problems where the consistency of polygonal ordering is corrupted due to topological loops.  
\item {\ttfamily obj.\-Non\-Manifold\-Traversal\-Off ()} -\/ Turn on/off traversal across non-\/manifold edges. This will prevent problems where the consistency of polygonal ordering is corrupted due to topological loops.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkpolydatapointsampler}{}\section{vtk\-Poly\-Data\-Point\-Sampler}\label{vtkgraphics_vtkpolydatapointsampler}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Poly\-Data\-Point\-Sampler generates points from input vtk\-Poly\-Data. The points are placed approximately a specified distance apart.

This filter functions as follows. First, it regurgitates all input points, then samples all lines, plus edges associated with the input polygons and triangle strips to produce edge points. Finally, the interiors of polygons and triangle strips are subsampled to produce points. All of these functiona can be enabled or disabled separately. Note that this algorithm only approximately generates points the specified distance apart. Generally the point density is finer than requested.

To create an instance of class vtk\-Poly\-Data\-Point\-Sampler, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPolyDataPointSampler
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Poly\-Data\-Point\-Sampler has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Point\-Sampler class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard macros for type information and printing.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard macros for type information and printing.  
\item {\ttfamily vtk\-Poly\-Data\-Point\-Sampler = obj.\-New\-Instance ()} -\/ Standard macros for type information and printing.  
\item {\ttfamily vtk\-Poly\-Data\-Point\-Sampler = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard macros for type information and printing.  
\item {\ttfamily obj.\-Set\-Distance (double )} -\/ Set/\-Get the approximate distance between points. This is an absolute distance measure. The default is 0.\-01.  
\item {\ttfamily double = obj.\-Get\-Distance\-Min\-Value ()} -\/ Set/\-Get the approximate distance between points. This is an absolute distance measure. The default is 0.\-01.  
\item {\ttfamily double = obj.\-Get\-Distance\-Max\-Value ()} -\/ Set/\-Get the approximate distance between points. This is an absolute distance measure. The default is 0.\-01.  
\item {\ttfamily double = obj.\-Get\-Distance ()} -\/ Set/\-Get the approximate distance between points. This is an absolute distance measure. The default is 0.\-01.  
\item {\ttfamily int = obj.\-Get\-Generate\-Vertex\-Points ()} -\/ Specify/retrieve a boolean flag indicating whether cell vertex points should be output.  
\item {\ttfamily obj.\-Set\-Generate\-Vertex\-Points (int )} -\/ Specify/retrieve a boolean flag indicating whether cell vertex points should be output.  
\item {\ttfamily obj.\-Generate\-Vertex\-Points\-On ()} -\/ Specify/retrieve a boolean flag indicating whether cell vertex points should be output.  
\item {\ttfamily obj.\-Generate\-Vertex\-Points\-Off ()} -\/ Specify/retrieve a boolean flag indicating whether cell vertex points should be output.  
\item {\ttfamily int = obj.\-Get\-Generate\-Edge\-Points ()} -\/ Specify/retrieve a boolean flag indicating whether cell edges should be sampled to produce output points. The default is true.  
\item {\ttfamily obj.\-Set\-Generate\-Edge\-Points (int )} -\/ Specify/retrieve a boolean flag indicating whether cell edges should be sampled to produce output points. The default is true.  
\item {\ttfamily obj.\-Generate\-Edge\-Points\-On ()} -\/ Specify/retrieve a boolean flag indicating whether cell edges should be sampled to produce output points. The default is true.  
\item {\ttfamily obj.\-Generate\-Edge\-Points\-Off ()} -\/ Specify/retrieve a boolean flag indicating whether cell edges should be sampled to produce output points. The default is true.  
\item {\ttfamily int = obj.\-Get\-Generate\-Interior\-Points ()} -\/ Specify/retrieve a boolean flag indicating whether cell interiors should be sampled to produce output points. The default is true.  
\item {\ttfamily obj.\-Set\-Generate\-Interior\-Points (int )} -\/ Specify/retrieve a boolean flag indicating whether cell interiors should be sampled to produce output points. The default is true.  
\item {\ttfamily obj.\-Generate\-Interior\-Points\-On ()} -\/ Specify/retrieve a boolean flag indicating whether cell interiors should be sampled to produce output points. The default is true.  
\item {\ttfamily obj.\-Generate\-Interior\-Points\-Off ()} -\/ Specify/retrieve a boolean flag indicating whether cell interiors should be sampled to produce output points. The default is true.  
\item {\ttfamily int = obj.\-Get\-Generate\-Vertices ()} -\/ Specify/retrieve a boolean flag indicating whether cell vertices should be generated. Cell vertices are useful if you actually want to display the points (that is, for each point generated, a vertex is generated). Recall that V\-T\-K only renders vertices and not points. The default is true.  
\item {\ttfamily obj.\-Set\-Generate\-Vertices (int )} -\/ Specify/retrieve a boolean flag indicating whether cell vertices should be generated. Cell vertices are useful if you actually want to display the points (that is, for each point generated, a vertex is generated). Recall that V\-T\-K only renders vertices and not points. The default is true.  
\item {\ttfamily obj.\-Generate\-Vertices\-On ()} -\/ Specify/retrieve a boolean flag indicating whether cell vertices should be generated. Cell vertices are useful if you actually want to display the points (that is, for each point generated, a vertex is generated). Recall that V\-T\-K only renders vertices and not points. The default is true.  
\item {\ttfamily obj.\-Generate\-Vertices\-Off ()} -\/ Specify/retrieve a boolean flag indicating whether cell vertices should be generated. Cell vertices are useful if you actually want to display the points (that is, for each point generated, a vertex is generated). Recall that V\-T\-K only renders vertices and not points. The default is true.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkpolydatastreamer}{}\section{vtk\-Poly\-Data\-Streamer}\label{vtkgraphics_vtkpolydatastreamer}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Poly\-Data\-Streamer initiates streaming by requesting pieces from its single input it appends these pieces it to the requested output. Note that since vtk\-Poly\-Data\-Streamer uses an append filter, all the polygons generated have to be kept in memory before rendering. If these do not fit in the memory, it is possible to make the vtk\-Poly\-Data\-Mapper stream. Since the mapper will render each piece separately, all the polygons do not have to stored in memory. .S\-E\-C\-T\-I\-O\-N Note The output may be slightly different if the pipeline does not handle ghost cells properly (i.\-e. you might see seames between the pieces).

To create an instance of class vtk\-Poly\-Data\-Streamer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPolyDataStreamer
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Poly\-Data\-Streamer has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Streamer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Poly\-Data\-Streamer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Poly\-Data\-Streamer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Number\-Of\-Stream\-Divisions (int num)} -\/ Set the number of pieces to divide the problem into.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Stream\-Divisions ()} -\/ Set the number of pieces to divide the problem into.  
\item {\ttfamily obj.\-Set\-Color\-By\-Piece (int )} -\/ By default, this option is off. When it is on, cell scalars are generated based on which piece they are in.  
\item {\ttfamily int = obj.\-Get\-Color\-By\-Piece ()} -\/ By default, this option is off. When it is on, cell scalars are generated based on which piece they are in.  
\item {\ttfamily obj.\-Color\-By\-Piece\-On ()} -\/ By default, this option is off. When it is on, cell scalars are generated based on which piece they are in.  
\item {\ttfamily obj.\-Color\-By\-Piece\-Off ()} -\/ By default, this option is off. When it is on, cell scalars are generated based on which piece they are in.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkprobefilter}{}\section{vtk\-Probe\-Filter}\label{vtkgraphics_vtkprobefilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Probe\-Filter is a filter that computes point attributes (e.\-g., scalars, vectors, etc.) at specified point positions. The filter has two inputs\-: the Input and Source. The Input geometric structure is passed through the filter. The point attributes are computed at the Input point positions by interpolating into the source data. For example, we can compute data values on a plane (plane specified as Input) from a volume (Source). The cell data of the source data is copied to the output based on in which source cell each input point is. If an array of the same name exists both in source's point and cell data, only the one from the point data is probed.

This filter can be used to resample data, or convert one dataset form into another. For example, an unstructured grid (vtk\-Unstructured\-Grid) can be probed with a volume (three-\/dimensional vtk\-Image\-Data), and then volume rendering techniques can be used to visualize the results. Another example\-: a line or curve can be used to probe data to produce x-\/y plots along that line or curve.

To create an instance of class vtk\-Probe\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkProbeFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Probe\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Probe\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Probe\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Probe\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Source (vtk\-Data\-Object source)} -\/ Specify the point locations used to probe input. Any geometry can be used. Old style. Do not use unless for backwards compatibility.  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Source ()} -\/ Specify the point locations used to probe input. Any geometry can be used. Old style. Do not use unless for backwards compatibility.  
\item {\ttfamily obj.\-Set\-Source\-Connection (vtk\-Algorithm\-Output alg\-Output)} -\/ Specify the point locations used to probe input. Any geometry can be used. New style. Equivalent to Set\-Input\-Connection(1, alg\-Output).  
\item {\ttfamily obj.\-Set\-Spatial\-Match (int )} -\/ This flag is used only when a piece is requested to update. By default the flag is off. Because no spatial correspondence between input pieces and source pieces is known, all of the source has to be requested no matter what piece of the output is requested. When there is a spatial correspondence, the user/application can set this flag. This hint allows the breakup of the probe operation to be much more efficient. When piece m of n is requested for update by the user, then only n of m needs to be requested of the source.  
\item {\ttfamily int = obj.\-Get\-Spatial\-Match ()} -\/ This flag is used only when a piece is requested to update. By default the flag is off. Because no spatial correspondence between input pieces and source pieces is known, all of the source has to be requested no matter what piece of the output is requested. When there is a spatial correspondence, the user/application can set this flag. This hint allows the breakup of the probe operation to be much more efficient. When piece m of n is requested for update by the user, then only n of m needs to be requested of the source.  
\item {\ttfamily obj.\-Spatial\-Match\-On ()} -\/ This flag is used only when a piece is requested to update. By default the flag is off. Because no spatial correspondence between input pieces and source pieces is known, all of the source has to be requested no matter what piece of the output is requested. When there is a spatial correspondence, the user/application can set this flag. This hint allows the breakup of the probe operation to be much more efficient. When piece m of n is requested for update by the user, then only n of m needs to be requested of the source.  
\item {\ttfamily obj.\-Spatial\-Match\-Off ()} -\/ This flag is used only when a piece is requested to update. By default the flag is off. Because no spatial correspondence between input pieces and source pieces is known, all of the source has to be requested no matter what piece of the output is requested. When there is a spatial correspondence, the user/application can set this flag. This hint allows the breakup of the probe operation to be much more efficient. When piece m of n is requested for update by the user, then only n of m needs to be requested of the source.  
\item {\ttfamily vtk\-Id\-Type\-Array = obj.\-Get\-Valid\-Points ()} -\/ Get the list of point ids in the output that contain attribute data interpolated from the source.  
\item {\ttfamily obj.\-Set\-Valid\-Point\-Mask\-Array\-Name (string )} -\/ Returns the name of the char array added to the output with values 1 for valid points and 0 for invalid points. Set to \char`\"{}vtk\-Valid\-Point\-Mask\char`\"{} by default.  
\item {\ttfamily string = obj.\-Get\-Valid\-Point\-Mask\-Array\-Name ()} -\/ Returns the name of the char array added to the output with values 1 for valid points and 0 for invalid points. Set to \char`\"{}vtk\-Valid\-Point\-Mask\char`\"{} by default.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkprobeselectedlocations}{}\section{vtk\-Probe\-Selected\-Locations}\label{vtkgraphics_vtkprobeselectedlocations}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Probe\-Selected\-Locations is similar to vtk\-Extract\-Selected\-Locations except that it interpolates the point attributes at the probe location. This is equivalent to the vtk\-Probe\-Filter except that the probe locations are provided by a vtk\-Selection. The Field\-Type of the input vtk\-Selection is immaterial and is ignored. The Content\-Type of the input vtk\-Selection must be vtk\-Selection\-::\-L\-O\-C\-A\-T\-I\-O\-N\-S.

To create an instance of class vtk\-Probe\-Selected\-Locations, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkProbeSelectedLocations
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Probe\-Selected\-Locations has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Probe\-Selected\-Locations class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Probe\-Selected\-Locations = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Probe\-Selected\-Locations = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkprogrammableattributedatafilter}{}\section{vtk\-Programmable\-Attribute\-Data\-Filter}\label{vtkgraphics_vtkprogrammableattributedatafilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Programmable\-Attribute\-Data\-Filter is a filter that allows you to write a custom procedure to manipulate attribute data -\/ either point or cell data. For example, you could generate scalars based on a complex formula; convert vectors to normals; compute scalar values as a function of vectors, texture coords, and/or any other point data attribute; and so on. The filter takes multiple inputs (input plus an auxiliary input list), so you can write procedures that combine several dataset point attributes. Note that the output of the filter is the same type (topology/geometry) as the input.

The filter works as follows. It operates like any other filter (i.\-e., checking and managing modified and execution times, processing Update() and Execute() methods, managing release of data, etc.), but the difference is that the Execute() method simply invokes a user-\/specified function with an optional (void $\ast$) argument (typically the \char`\"{}this\char`\"{} pointer in C++). It is also possible to specify a function to delete the argument via Execute\-Method\-Arg\-Delete().

To use the filter, you write a procedure to process the input datasets, process the data, and generate output data. Typically, this means grabbing the input point or cell data (using Get\-Input() and maybe Get\-Input\-List()), operating on it (creating new point and cell attributes such as scalars, vectors, etc.), and then setting the point and/or cell attributes in the output dataset (you'll need to use Get\-Output() to access the output). (Note\-: besides C++, it is possible to do the same thing in Tcl, Java, or other languages that wrap the C++ core.) Remember, proper filter protocol requires that you don't modify the input data -\/ you create new output data from the input.

To create an instance of class vtk\-Programmable\-Attribute\-Data\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkProgrammableAttributeDataFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Programmable\-Attribute\-Data\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Programmable\-Attribute\-Data\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Programmable\-Attribute\-Data\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Programmable\-Attribute\-Data\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Input (vtk\-Data\-Set in)} -\/ Add a dataset to the list of data to process.  
\item {\ttfamily obj.\-Remove\-Input (vtk\-Data\-Set in)} -\/ Remove a dataset from the list of data to process.  
\item {\ttfamily vtk\-Data\-Set\-Collection = obj.\-Get\-Input\-List ()} -\/ Return the list of inputs.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkprogrammabledataobjectsource}{}\section{vtk\-Programmable\-Data\-Object\-Source}\label{vtkgraphics_vtkprogrammabledataobjectsource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Programmable\-Data\-Object\-Source is a source object that is programmable by the user. The output of the filter is a data object (vtk\-Data\-Object) which represents data via an instance of field data. To use this object, you must specify a function that creates the output.

Example use of this filter includes reading tabular data and encoding it as vtk\-Field\-Data. You can then use filters like vtk\-Data\-Object\-To\-Data\-Set\-Filter to convert the data object to a dataset and then visualize it. Another important use of this class is that it allows users of interpreters (e.\-g., Tcl or Java) the ability to write source objects without having to recompile C++ code or generate new libraries.

To create an instance of class vtk\-Programmable\-Data\-Object\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkProgrammableDataObjectSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Programmable\-Data\-Object\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Programmable\-Data\-Object\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Programmable\-Data\-Object\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Programmable\-Data\-Object\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkprogrammablefilter}{}\section{vtk\-Programmable\-Filter}\label{vtkgraphics_vtkprogrammablefilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Programmable\-Filter is a filter that can be programmed by the user. To use the filter you define a function that retrieves input of the correct type, creates data, and then manipulates the output of the filter. Using this filter avoids the need for subclassing -\/ and the function can be defined in an interpreter wrapper language such as Tcl or Java.

The trickiest part of using this filter is that the input and output methods are unusual and cannot be compile-\/time type checked. Instead, as a user of this filter it is your responsibility to set and get the correct input and output types.

To create an instance of class vtk\-Programmable\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkProgrammableFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Programmable\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Programmable\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Programmable\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Programmable\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Poly\-Data\-Input ()} -\/ Get the input as a concrete type. This method is typically used by the writer of the filter function to get the input as a particular type (i.\-e., it essentially does type casting). It is the users responsibility to know the correct type of the input data.  
\item {\ttfamily vtk\-Structured\-Points = obj.\-Get\-Structured\-Points\-Input ()} -\/ Get the input as a concrete type.  
\item {\ttfamily vtk\-Structured\-Grid = obj.\-Get\-Structured\-Grid\-Input ()} -\/ Get the input as a concrete type.  
\item {\ttfamily vtk\-Unstructured\-Grid = obj.\-Get\-Unstructured\-Grid\-Input ()} -\/ Get the input as a concrete type.  
\item {\ttfamily vtk\-Rectilinear\-Grid = obj.\-Get\-Rectilinear\-Grid\-Input ()} -\/ Get the input as a concrete type.  
\item {\ttfamily vtk\-Graph = obj.\-Get\-Graph\-Input ()} -\/ Get the input as a concrete type.  
\item {\ttfamily vtk\-Table = obj.\-Get\-Table\-Input ()} -\/ Get the input as a concrete type.  
\item {\ttfamily obj.\-Set\-Copy\-Arrays (bool )} -\/ When Copy\-Arrays is true, all arrays are copied to the output iff input and output are of the same type. False by default.  
\item {\ttfamily bool = obj.\-Get\-Copy\-Arrays ()} -\/ When Copy\-Arrays is true, all arrays are copied to the output iff input and output are of the same type. False by default.  
\item {\ttfamily obj.\-Copy\-Arrays\-On ()} -\/ When Copy\-Arrays is true, all arrays are copied to the output iff input and output are of the same type. False by default.  
\item {\ttfamily obj.\-Copy\-Arrays\-Off ()} -\/ When Copy\-Arrays is true, all arrays are copied to the output iff input and output are of the same type. False by default.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkprogrammableglyphfilter}{}\section{vtk\-Programmable\-Glyph\-Filter}\label{vtkgraphics_vtkprogrammableglyphfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Programmable\-Glyph\-Filter is a filter that allows you to place a glyph at each input point in the dataset. In addition, the filter is programmable which means the user has control over the generation of the glyph. The glyphs can be controlled via the point data attributes (e.\-g., scalars, vectors, etc.) or any other information in the input dataset.

This is the way the filter works. You must define an input dataset which at a minimum contains points with associated attribute values. Also, the Source instance variable must be set which is of type vtk\-Poly\-Data. Then, for each point in the input, the Point\-Id is set to the current point id, and a user-\/defined function is called (i.\-e., Glyph\-Method). In this method you can manipulate the Source data (including changing to a different Source object). After the Glyph\-Method is called, vtk\-Programmable\-Glyph\-Filter will invoke an Update() on its Source object, and then copy its data to the output of the vtk\-Programmable\-Glyph\-Filter. Therefore the output of this filter is of type vtk\-Poly\-Data.

Another option to this filter is the way you color the glyphs. You can use the scalar data from the input or the source. The instance variable Color\-Mode controls this behavior.

To create an instance of class vtk\-Programmable\-Glyph\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkProgrammableGlyphFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Programmable\-Glyph\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Programmable\-Glyph\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Programmable\-Glyph\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Programmable\-Glyph\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Source (vtk\-Poly\-Data source)} -\/ Set/\-Get the source to use for this glyph. Note\-: you can change the source during execution of this filter.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Source ()} -\/ Set/\-Get the source to use for this glyph. Note\-: you can change the source during execution of this filter.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Point\-Id ()} -\/ Get the current point id during processing. Value only valid during the Execute() method of this filter. (Meant to be called by the Glyph\-Method().)  
\item {\ttfamily double = obj. Get\-Point ()} -\/ Get the current point coordinates during processing. Value only valid during the Execute() method of this filter. (Meant to be called by the Glyph\-Method().)  
\item {\ttfamily vtk\-Point\-Data = obj.\-Get\-Point\-Data ()} -\/ Get the set of point data attributes for the input. A convenience to the programmer to be used in the Glyph\-Method(). Only valid during the Execute() method of this filter.  
\item {\ttfamily obj.\-Set\-Color\-Mode (int )} -\/ Either color by the input or source scalar data.  
\item {\ttfamily int = obj.\-Get\-Color\-Mode ()} -\/ Either color by the input or source scalar data.  
\item {\ttfamily obj.\-Set\-Color\-Mode\-To\-Color\-By\-Input ()} -\/ Either color by the input or source scalar data.  
\item {\ttfamily obj.\-Set\-Color\-Mode\-To\-Color\-By\-Source ()} -\/ Either color by the input or source scalar data.  
\item {\ttfamily string = obj.\-Get\-Color\-Mode\-As\-String ()} -\/ Either color by the input or source scalar data.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkprogrammablesource}{}\section{vtk\-Programmable\-Source}\label{vtkgraphics_vtkprogrammablesource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Programmable\-Source is a source object that is programmable by the user. To use this object, you must specify a function that creates the output. It is possible to generate an output dataset of any (concrete) type; it is up to the function to properly initialize and define the output. Typically, you use one of the methods to get a concrete output type (e.\-g., Get\-Poly\-Data\-Output() or Get\-Structured\-Points\-Output()), and then manipulate the output in the user-\/specified function.

Example use of this include writing a function to read a data file or interface to another system. (You might want to do this in favor of deriving a new class.) Another important use of this class is that it allows users of interpreters (e.\-g., Tcl or Java) the ability to write source objects without having to recompile C++ code or generate new libraries.

To create an instance of class vtk\-Programmable\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkProgrammableSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Programmable\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Programmable\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Programmable\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Programmable\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Poly\-Data\-Output ()} -\/ Get the output as a concrete type. This method is typically used by the writer of the source function to get the output as a particular type (i.\-e., it essentially does type casting). It is the users responsibility to know the correct type of the output data.  
\item {\ttfamily vtk\-Structured\-Points = obj.\-Get\-Structured\-Points\-Output ()} -\/ Get the output as a concrete type.  
\item {\ttfamily vtk\-Structured\-Grid = obj.\-Get\-Structured\-Grid\-Output ()} -\/ Get the output as a concrete type.  
\item {\ttfamily vtk\-Unstructured\-Grid = obj.\-Get\-Unstructured\-Grid\-Output ()} -\/ Get the output as a concrete type.  
\item {\ttfamily vtk\-Rectilinear\-Grid = obj.\-Get\-Rectilinear\-Grid\-Output ()} -\/ Get the output as a concrete type.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkprojectedtexture}{}\section{vtk\-Projected\-Texture}\label{vtkgraphics_vtkprojectedtexture}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Projected\-Texture assigns texture coordinates to a dataset as if the texture was projected from a slide projected located somewhere in the scene. Methods are provided to position the projector and aim it at a location, to set the width of the projector's frustum, and to set the range of texture coordinates assigned to the dataset.

Objects in the scene that appear behind the projector are also assigned texture coordinates; the projected image is left-\/right and top-\/bottom flipped, much as a lens' focus flips the rays of light that pass through it. A warning is issued if a point in the dataset falls at the focus of the projector.

To create an instance of class vtk\-Projected\-Texture, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkProjectedTexture
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Projected\-Texture has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Projected\-Texture class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Projected\-Texture = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Projected\-Texture = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Position (double , double , double )} -\/ Set/\-Get the position of the focus of the projector.  
\item {\ttfamily obj.\-Set\-Position (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of the focus of the projector.  
\item {\ttfamily double = obj. Get\-Position ()} -\/ Set/\-Get the position of the focus of the projector.  
\item {\ttfamily obj.\-Set\-Focal\-Point (double focal\-Point\mbox{[}3\mbox{]})} -\/ Set/\-Get the focal point of the projector (a point that lies along the center axis of the projector's frustum).  
\item {\ttfamily obj.\-Set\-Focal\-Point (double x, double y, double z)} -\/ Set/\-Get the focal point of the projector (a point that lies along the center axis of the projector's frustum).  
\item {\ttfamily double = obj. Get\-Focal\-Point ()} -\/ Set/\-Get the focal point of the projector (a point that lies along the center axis of the projector's frustum).  
\item {\ttfamily obj.\-Set\-Camera\-Mode (int )} -\/ Set/\-Get the camera mode of the projection -- pinhole projection or two mirror projection.  
\item {\ttfamily int = obj.\-Get\-Camera\-Mode ()} -\/ Set/\-Get the camera mode of the projection -- pinhole projection or two mirror projection.  
\item {\ttfamily obj.\-Set\-Camera\-Mode\-To\-Pinhole ()} -\/ Set/\-Get the camera mode of the projection -- pinhole projection or two mirror projection.  
\item {\ttfamily obj.\-Set\-Camera\-Mode\-To\-Two\-Mirror ()} -\/ Set/\-Get the mirror separation for the two mirror system.  
\item {\ttfamily obj.\-Set\-Mirror\-Separation (double )} -\/ Set/\-Get the mirror separation for the two mirror system.  
\item {\ttfamily double = obj.\-Get\-Mirror\-Separation ()} -\/ Set/\-Get the mirror separation for the two mirror system.  
\item {\ttfamily double = obj. Get\-Orientation ()} -\/ Get the normalized orientation vector of the projector.  
\item {\ttfamily obj.\-Set\-Up (double , double , double )}  
\item {\ttfamily obj.\-Set\-Up (double a\mbox{[}3\mbox{]})}  
\item {\ttfamily double = obj. Get\-Up ()}  
\item {\ttfamily obj.\-Set\-Aspect\-Ratio (double , double , double )}  
\item {\ttfamily obj.\-Set\-Aspect\-Ratio (double a\mbox{[}3\mbox{]})}  
\item {\ttfamily double = obj. Get\-Aspect\-Ratio ()}  
\item {\ttfamily obj.\-Set\-S\-Range (double , double )} -\/ Specify s-\/coordinate range for texture s-\/t coordinate pair.  
\item {\ttfamily obj.\-Set\-S\-Range (double a\mbox{[}2\mbox{]})} -\/ Specify s-\/coordinate range for texture s-\/t coordinate pair.  
\item {\ttfamily double = obj. Get\-S\-Range ()} -\/ Specify s-\/coordinate range for texture s-\/t coordinate pair.  
\item {\ttfamily obj.\-Set\-T\-Range (double , double )} -\/ Specify t-\/coordinate range for texture s-\/t coordinate pair.  
\item {\ttfamily obj.\-Set\-T\-Range (double a\mbox{[}2\mbox{]})} -\/ Specify t-\/coordinate range for texture s-\/t coordinate pair.  
\item {\ttfamily double = obj. Get\-T\-Range ()} -\/ Specify t-\/coordinate range for texture s-\/t coordinate pair.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkquadraturepointinterpolator}{}\section{vtk\-Quadrature\-Point\-Interpolator}\label{vtkgraphics_vtkquadraturepointinterpolator}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Interpolates each scalar/vector field in a vtk\-Unstrctured\-Grid on its input to a specific set of quadrature points. The set of quadrature points is specified per array via a dictionary (ie an instance of vtk\-Information\-Quadrature\-Scheme\-Definition\-Vector\-Key). contained in the array. The interpolated fields are placed in Field\-Data along with a set of per cell indexes, that allow random access to a given cells quadrature points.

To create an instance of class vtk\-Quadrature\-Point\-Interpolator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkQuadraturePointInterpolator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Quadrature\-Point\-Interpolator has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Quadrature\-Point\-Interpolator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Quadrature\-Point\-Interpolator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Quadrature\-Point\-Interpolator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkquadraturepointsgenerator}{}\section{vtk\-Quadrature\-Points\-Generator}\label{vtkgraphics_vtkquadraturepointsgenerator}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Create a vtk\-Poly\-Data on its output containing the vertices for the quadrature points for one of the vtk\-Data\-Arrays present on its input vtk\-Unstructured\-Grid. If the input data set has has Field\-Data generated by vtk\-Quadrature\-Point\-Interpolator then this will be set as point data. Note\-: Point sets are generated per field array. This is because each field array may contain its own dictionary.

.S\-E\-C\-T\-I\-O\-N See also vtk\-Quadrature\-Point\-Interpolator, vtk\-Quadrature\-Scheme\-Definition, vtk\-Information\-Quadrature\-Scheme\-Definition\-Vector\-Key

To create an instance of class vtk\-Quadrature\-Points\-Generator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkQuadraturePointsGenerator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Quadrature\-Points\-Generator has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Quadrature\-Points\-Generator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Quadrature\-Points\-Generator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Quadrature\-Points\-Generator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkquadratureschemedictionarygenerator}{}\section{vtk\-Quadrature\-Scheme\-Dictionary\-Generator}\label{vtkgraphics_vtkquadratureschemedictionarygenerator}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Given an unstructured grid on its input this filter generates for each data array in point data dictionary (ie an instance of vtk\-Information\-Quadrature\-Scheme\-Definition\-Vector\-Key). This filter has been introduced to facilitate testing of the vtk\-Quadrature$\ast$ classes as these cannot operate with the dictionary. This class is for testing and should not be used for application development.

.S\-E\-C\-T\-I\-O\-N See also vtk\-Quadrature\-Point\-Interpolator, vtk\-Quadrature\-Points\-Generator, vtk\-Quadrature\-Scheme\-Definition

To create an instance of class vtk\-Quadrature\-Scheme\-Dictionary\-Generator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkQuadratureSchemeDictionaryGenerator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Quadrature\-Scheme\-Dictionary\-Generator has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Quadrature\-Scheme\-Dictionary\-Generator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Quadrature\-Scheme\-Dictionary\-Generator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Quadrature\-Scheme\-Dictionary\-Generator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkquadricclustering}{}\section{vtk\-Quadric\-Clustering}\label{vtkgraphics_vtkquadricclustering}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Quadric\-Clustering is a filter to reduce the number of triangles in a triangle mesh, forming a good approximation to the original geometry. The input to vtk\-Quadric\-Clustering is a vtk\-Poly\-Data object, and all types of polygonal data are handled.

The algorithm used is the one described by Peter Lindstrom in his Siggraph 2000 paper, \char`\"{}\-Out-\/of-\/\-Core Simplification of Large Polygonal Models.\char`\"{} The general approach of the algorithm is to cluster vertices in a uniform binning of space, accumulating the quadric of each triangle (pushed out to the triangles vertices) within each bin, and then determining an optimal position for a single vertex in a bin by using the accumulated quadric. In more detail, the algorithm first gets the bounds of the input poly data. It then breaks this bounding volume into a user-\/specified number of spatial bins. It then reads each triangle from the input and hashes its vertices into these bins. (If this is the first time a bin has been visited, initialize its quadric to the 0 matrix.) The algorithm computes the error quadric for this triangle and adds it to the existing quadric of the bin in which each vertex is contained. Then, if 2 or more vertices of the triangle fall in the same bin, the triangle is dicarded. If the triangle is not discarded, it adds the triangle to the list of output triangles as a list of vertex identifiers. (There is one vertex id per bin.) After all the triangles have been read, the representative vertex for each bin is computed (an optimal location is found) using the quadric for that bin. This determines the spatial location of the vertices of each of the triangles in the output.

To use this filter, specify the divisions defining the spatial subdivision in the x, y, and z directions. You must also specify an input vtk\-Poly\-Data. Then choose to either 1) use the original points that minimize the quadric error to produce the output triangles or 2) compute an optimal position in each bin to produce the output triangles (recommended and default behavior).

This filter can take multiple inputs. To do this, the user must explicity call Start\-Append, Append (once for each input), and End\-Append. Start\-Append sets up the data structure to hold the quadric matrices. Append processes each triangle in the input poly data it was called on, hashes its vertices to the appropriate bins, determines whether to keep this triangle, and updates the appropriate quadric matrices. End\-Append determines the spatial location of each of the representative vertices for the visited bins. While this approach does not fit into the visualization architecture and requires manual control, it has the advantage that extremely large data can be processed in pieces and appended to the filter piece-\/by-\/piece.

To create an instance of class vtk\-Quadric\-Clustering, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkQuadricClustering
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Quadric\-Clustering has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Quadric\-Clustering class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard instantition, type and print methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard instantition, type and print methods.  
\item {\ttfamily vtk\-Quadric\-Clustering = obj.\-New\-Instance ()} -\/ Standard instantition, type and print methods.  
\item {\ttfamily vtk\-Quadric\-Clustering = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard instantition, type and print methods.  
\item {\ttfamily obj.\-Set\-Number\-Of\-X\-Divisions (int num)} -\/ Set/\-Get the number of divisions along each axis for the spatial bins. The number of spatial bins is Number\-Of\-X\-Divisions$\ast$\-Number\-Of\-Y\-Divisions$\ast$ Number\-Of\-Z\-Divisions. The filter may choose to ignore large numbers of divisions if the input has few points and Auto\-Adjust\-Number\-Of\-Divisions is enabled.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Y\-Divisions (int num)} -\/ Set/\-Get the number of divisions along each axis for the spatial bins. The number of spatial bins is Number\-Of\-X\-Divisions$\ast$\-Number\-Of\-Y\-Divisions$\ast$ Number\-Of\-Z\-Divisions. The filter may choose to ignore large numbers of divisions if the input has few points and Auto\-Adjust\-Number\-Of\-Divisions is enabled.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Z\-Divisions (int num)} -\/ Set/\-Get the number of divisions along each axis for the spatial bins. The number of spatial bins is Number\-Of\-X\-Divisions$\ast$\-Number\-Of\-Y\-Divisions$\ast$ Number\-Of\-Z\-Divisions. The filter may choose to ignore large numbers of divisions if the input has few points and Auto\-Adjust\-Number\-Of\-Divisions is enabled.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-X\-Divisions ()} -\/ Set/\-Get the number of divisions along each axis for the spatial bins. The number of spatial bins is Number\-Of\-X\-Divisions$\ast$\-Number\-Of\-Y\-Divisions$\ast$ Number\-Of\-Z\-Divisions. The filter may choose to ignore large numbers of divisions if the input has few points and Auto\-Adjust\-Number\-Of\-Divisions is enabled.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Y\-Divisions ()} -\/ Set/\-Get the number of divisions along each axis for the spatial bins. The number of spatial bins is Number\-Of\-X\-Divisions$\ast$\-Number\-Of\-Y\-Divisions$\ast$ Number\-Of\-Z\-Divisions. The filter may choose to ignore large numbers of divisions if the input has few points and Auto\-Adjust\-Number\-Of\-Divisions is enabled.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Z\-Divisions ()} -\/ Set/\-Get the number of divisions along each axis for the spatial bins. The number of spatial bins is Number\-Of\-X\-Divisions$\ast$\-Number\-Of\-Y\-Divisions$\ast$ Number\-Of\-Z\-Divisions. The filter may choose to ignore large numbers of divisions if the input has few points and Auto\-Adjust\-Number\-Of\-Divisions is enabled.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Divisions (int div\mbox{[}3\mbox{]})} -\/ Set/\-Get the number of divisions along each axis for the spatial bins. The number of spatial bins is Number\-Of\-X\-Divisions$\ast$\-Number\-Of\-Y\-Divisions$\ast$ Number\-Of\-Z\-Divisions. The filter may choose to ignore large numbers of divisions if the input has few points and Auto\-Adjust\-Number\-Of\-Divisions is enabled.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Divisions (int div0, int div1, int div2)} -\/ Set/\-Get the number of divisions along each axis for the spatial bins. The number of spatial bins is Number\-Of\-X\-Divisions$\ast$\-Number\-Of\-Y\-Divisions$\ast$ Number\-Of\-Z\-Divisions. The filter may choose to ignore large numbers of divisions if the input has few points and Auto\-Adjust\-Number\-Of\-Divisions is enabled.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Divisions ()} -\/ Set/\-Get the number of divisions along each axis for the spatial bins. The number of spatial bins is Number\-Of\-X\-Divisions$\ast$\-Number\-Of\-Y\-Divisions$\ast$ Number\-Of\-Z\-Divisions. The filter may choose to ignore large numbers of divisions if the input has few points and Auto\-Adjust\-Number\-Of\-Divisions is enabled.  
\item {\ttfamily obj.\-Get\-Number\-Of\-Divisions (int div\mbox{[}3\mbox{]})} -\/ Set/\-Get the number of divisions along each axis for the spatial bins. The number of spatial bins is Number\-Of\-X\-Divisions$\ast$\-Number\-Of\-Y\-Divisions$\ast$ Number\-Of\-Z\-Divisions. The filter may choose to ignore large numbers of divisions if the input has few points and Auto\-Adjust\-Number\-Of\-Divisions is enabled.  
\item {\ttfamily obj.\-Set\-Auto\-Adjust\-Number\-Of\-Divisions (int )} -\/ Enable automatic adjustment of number of divisions. If off, the number of divisions specified by the user is always used (as long as it is valid). The default is On  
\item {\ttfamily int = obj.\-Get\-Auto\-Adjust\-Number\-Of\-Divisions ()} -\/ Enable automatic adjustment of number of divisions. If off, the number of divisions specified by the user is always used (as long as it is valid). The default is On  
\item {\ttfamily obj.\-Auto\-Adjust\-Number\-Of\-Divisions\-On ()} -\/ Enable automatic adjustment of number of divisions. If off, the number of divisions specified by the user is always used (as long as it is valid). The default is On  
\item {\ttfamily obj.\-Auto\-Adjust\-Number\-Of\-Divisions\-Off ()} -\/ Enable automatic adjustment of number of divisions. If off, the number of divisions specified by the user is always used (as long as it is valid). The default is On  
\item {\ttfamily obj.\-Set\-Division\-Origin (double x, double y, double z)} -\/ This is an alternative way to set up the bins. If you are trying to match boundaries between pieces, then you should use these methods rather than Set\-Number\-Of\-Divisions. To use these methods, specify the origin and spacing of the spatial binning.  
\item {\ttfamily obj.\-Set\-Division\-Origin (double o\mbox{[}3\mbox{]})} -\/ This is an alternative way to set up the bins. If you are trying to match boundaries between pieces, then you should use these methods rather than Set\-Number\-Of\-Divisions. To use these methods, specify the origin and spacing of the spatial binning.  
\item {\ttfamily double = obj. Get\-Division\-Origin ()} -\/ This is an alternative way to set up the bins. If you are trying to match boundaries between pieces, then you should use these methods rather than Set\-Number\-Of\-Divisions. To use these methods, specify the origin and spacing of the spatial binning.  
\item {\ttfamily obj.\-Set\-Division\-Spacing (double x, double y, double z)} -\/ This is an alternative way to set up the bins. If you are trying to match boundaries between pieces, then you should use these methods rather than Set\-Number\-Of\-Divisions. To use these methods, specify the origin and spacing of the spatial binning.  
\item {\ttfamily obj.\-Set\-Division\-Spacing (double s\mbox{[}3\mbox{]})} -\/ This is an alternative way to set up the bins. If you are trying to match boundaries between pieces, then you should use these methods rather than Set\-Number\-Of\-Divisions. To use these methods, specify the origin and spacing of the spatial binning.  
\item {\ttfamily double = obj. Get\-Division\-Spacing ()} -\/ This is an alternative way to set up the bins. If you are trying to match boundaries between pieces, then you should use these methods rather than Set\-Number\-Of\-Divisions. To use these methods, specify the origin and spacing of the spatial binning.  
\item {\ttfamily obj.\-Set\-Use\-Input\-Points (int )} -\/ Normally the point that minimizes the quadric error function is used as the output of the bin. When this flag is on, the bin point is forced to be one of the points from the input (the one with the smallest error). This option does not work (i.\-e., input points cannot be used) when the append methods (Start\-Append(), Append(), End\-Append()) are being called directly.  
\item {\ttfamily int = obj.\-Get\-Use\-Input\-Points ()} -\/ Normally the point that minimizes the quadric error function is used as the output of the bin. When this flag is on, the bin point is forced to be one of the points from the input (the one with the smallest error). This option does not work (i.\-e., input points cannot be used) when the append methods (Start\-Append(), Append(), End\-Append()) are being called directly.  
\item {\ttfamily obj.\-Use\-Input\-Points\-On ()} -\/ Normally the point that minimizes the quadric error function is used as the output of the bin. When this flag is on, the bin point is forced to be one of the points from the input (the one with the smallest error). This option does not work (i.\-e., input points cannot be used) when the append methods (Start\-Append(), Append(), End\-Append()) are being called directly.  
\item {\ttfamily obj.\-Use\-Input\-Points\-Off ()} -\/ Normally the point that minimizes the quadric error function is used as the output of the bin. When this flag is on, the bin point is forced to be one of the points from the input (the one with the smallest error). This option does not work (i.\-e., input points cannot be used) when the append methods (Start\-Append(), Append(), End\-Append()) are being called directly.  
\item {\ttfamily obj.\-Set\-Use\-Feature\-Edges (int )} -\/ By default, this flag is off. When \char`\"{}\-Use\-Feature\-Edges\char`\"{} is on, then quadrics are computed for boundary edges/feature edges. They influence the quadrics (position of points), but not the mesh. Which features to use can be controlled by the filter \char`\"{}\-Feature\-Edges\char`\"{}.  
\item {\ttfamily int = obj.\-Get\-Use\-Feature\-Edges ()} -\/ By default, this flag is off. When \char`\"{}\-Use\-Feature\-Edges\char`\"{} is on, then quadrics are computed for boundary edges/feature edges. They influence the quadrics (position of points), but not the mesh. Which features to use can be controlled by the filter \char`\"{}\-Feature\-Edges\char`\"{}.  
\item {\ttfamily obj.\-Use\-Feature\-Edges\-On ()} -\/ By default, this flag is off. When \char`\"{}\-Use\-Feature\-Edges\char`\"{} is on, then quadrics are computed for boundary edges/feature edges. They influence the quadrics (position of points), but not the mesh. Which features to use can be controlled by the filter \char`\"{}\-Feature\-Edges\char`\"{}.  
\item {\ttfamily obj.\-Use\-Feature\-Edges\-Off ()} -\/ By default, this flag is off. When \char`\"{}\-Use\-Feature\-Edges\char`\"{} is on, then quadrics are computed for boundary edges/feature edges. They influence the quadrics (position of points), but not the mesh. Which features to use can be controlled by the filter \char`\"{}\-Feature\-Edges\char`\"{}.  
\item {\ttfamily vtk\-Feature\-Edges = obj.\-Get\-Feature\-Edges ()} -\/ By default, this flag is off. It only has an effect when \char`\"{}\-Use\-Feature\-Edges\char`\"{} is also on. When \char`\"{}\-Use\-Feature\-Points\char`\"{} is on, then quadrics are computed for boundary / feature points used in the boundary / feature edges. They influence the quadrics (position of points), but not the mesh.  
\item {\ttfamily obj.\-Set\-Use\-Feature\-Points (int )} -\/ By default, this flag is off. It only has an effect when \char`\"{}\-Use\-Feature\-Edges\char`\"{} is also on. When \char`\"{}\-Use\-Feature\-Points\char`\"{} is on, then quadrics are computed for boundary / feature points used in the boundary / feature edges. They influence the quadrics (position of points), but not the mesh.  
\item {\ttfamily int = obj.\-Get\-Use\-Feature\-Points ()} -\/ By default, this flag is off. It only has an effect when \char`\"{}\-Use\-Feature\-Edges\char`\"{} is also on. When \char`\"{}\-Use\-Feature\-Points\char`\"{} is on, then quadrics are computed for boundary / feature points used in the boundary / feature edges. They influence the quadrics (position of points), but not the mesh.  
\item {\ttfamily obj.\-Use\-Feature\-Points\-On ()} -\/ By default, this flag is off. It only has an effect when \char`\"{}\-Use\-Feature\-Edges\char`\"{} is also on. When \char`\"{}\-Use\-Feature\-Points\char`\"{} is on, then quadrics are computed for boundary / feature points used in the boundary / feature edges. They influence the quadrics (position of points), but not the mesh.  
\item {\ttfamily obj.\-Use\-Feature\-Points\-Off ()} -\/ By default, this flag is off. It only has an effect when \char`\"{}\-Use\-Feature\-Edges\char`\"{} is also on. When \char`\"{}\-Use\-Feature\-Points\char`\"{} is on, then quadrics are computed for boundary / feature points used in the boundary / feature edges. They influence the quadrics (position of points), but not the mesh.  
\item {\ttfamily obj.\-Set\-Feature\-Points\-Angle (double )} -\/ Set/\-Get the angle to use in determining whether a point on a boundary / feature edge is a feature point.  
\item {\ttfamily double = obj.\-Get\-Feature\-Points\-Angle\-Min\-Value ()} -\/ Set/\-Get the angle to use in determining whether a point on a boundary / feature edge is a feature point.  
\item {\ttfamily double = obj.\-Get\-Feature\-Points\-Angle\-Max\-Value ()} -\/ Set/\-Get the angle to use in determining whether a point on a boundary / feature edge is a feature point.  
\item {\ttfamily double = obj.\-Get\-Feature\-Points\-Angle ()} -\/ Set/\-Get the angle to use in determining whether a point on a boundary / feature edge is a feature point.  
\item {\ttfamily obj.\-Set\-Use\-Internal\-Triangles (int )} -\/ When this flag is on (and it is on by default), then triangles that are completely contained in a bin are added to the bin quadrics. When the the flag is off the filter operates faster, but the surface may not be as well behaved.  
\item {\ttfamily int = obj.\-Get\-Use\-Internal\-Triangles ()} -\/ When this flag is on (and it is on by default), then triangles that are completely contained in a bin are added to the bin quadrics. When the the flag is off the filter operates faster, but the surface may not be as well behaved.  
\item {\ttfamily obj.\-Use\-Internal\-Triangles\-On ()} -\/ When this flag is on (and it is on by default), then triangles that are completely contained in a bin are added to the bin quadrics. When the the flag is off the filter operates faster, but the surface may not be as well behaved.  
\item {\ttfamily obj.\-Use\-Internal\-Triangles\-Off ()} -\/ When this flag is on (and it is on by default), then triangles that are completely contained in a bin are added to the bin quadrics. When the the flag is off the filter operates faster, but the surface may not be as well behaved.  
\item {\ttfamily obj.\-Start\-Append (double bounds)} -\/ These methods provide an alternative way of executing the filter. Poly\-Data can be added to the result in pieces (append). In this mode, the user must specify the bounds of the entire model as an argument to the \char`\"{}\-Start\-Append\char`\"{} method.  
\item {\ttfamily obj.\-Start\-Append (double x0, double x1, double y0, double y1, double z0, double z1)} -\/ These methods provide an alternative way of executing the filter. Poly\-Data can be added to the result in pieces (append). In this mode, the user must specify the bounds of the entire model as an argument to the \char`\"{}\-Start\-Append\char`\"{} method.  
\item {\ttfamily obj.\-Append (vtk\-Poly\-Data piece)} -\/ These methods provide an alternative way of executing the filter. Poly\-Data can be added to the result in pieces (append). In this mode, the user must specify the bounds of the entire model as an argument to the \char`\"{}\-Start\-Append\char`\"{} method.  
\item {\ttfamily obj.\-End\-Append ()} -\/ These methods provide an alternative way of executing the filter. Poly\-Data can be added to the result in pieces (append). In this mode, the user must specify the bounds of the entire model as an argument to the \char`\"{}\-Start\-Append\char`\"{} method.  
\item {\ttfamily obj.\-Set\-Copy\-Cell\-Data (int )} -\/ This flag makes the filter copy cell data from input to output (the best it can). It uses input cells that trigger the addition of output cells (no averaging). This is off by default, and does not work when append is being called explicitely (non-\/pipeline usage).  
\item {\ttfamily int = obj.\-Get\-Copy\-Cell\-Data ()} -\/ This flag makes the filter copy cell data from input to output (the best it can). It uses input cells that trigger the addition of output cells (no averaging). This is off by default, and does not work when append is being called explicitely (non-\/pipeline usage).  
\item {\ttfamily obj.\-Copy\-Cell\-Data\-On ()} -\/ This flag makes the filter copy cell data from input to output (the best it can). It uses input cells that trigger the addition of output cells (no averaging). This is off by default, and does not work when append is being called explicitely (non-\/pipeline usage).  
\item {\ttfamily obj.\-Copy\-Cell\-Data\-Off ()} -\/ This flag makes the filter copy cell data from input to output (the best it can). It uses input cells that trigger the addition of output cells (no averaging). This is off by default, and does not work when append is being called explicitely (non-\/pipeline usage).  
\item {\ttfamily obj.\-Set\-Prevent\-Duplicate\-Cells (int )} -\/ Specify a boolean indicating whether to remove duplicate cells (i.\-e. triangles). This is a little slower, and takes more memory, but in some cases can reduce the number of cells produced by an order of magnitude. By default, this flag is true.  
\item {\ttfamily int = obj.\-Get\-Prevent\-Duplicate\-Cells ()} -\/ Specify a boolean indicating whether to remove duplicate cells (i.\-e. triangles). This is a little slower, and takes more memory, but in some cases can reduce the number of cells produced by an order of magnitude. By default, this flag is true.  
\item {\ttfamily obj.\-Prevent\-Duplicate\-Cells\-On ()} -\/ Specify a boolean indicating whether to remove duplicate cells (i.\-e. triangles). This is a little slower, and takes more memory, but in some cases can reduce the number of cells produced by an order of magnitude. By default, this flag is true.  
\item {\ttfamily obj.\-Prevent\-Duplicate\-Cells\-Off ()} -\/ Specify a boolean indicating whether to remove duplicate cells (i.\-e. triangles). This is a little slower, and takes more memory, but in some cases can reduce the number of cells produced by an order of magnitude. By default, this flag is true.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkquadricdecimation}{}\section{vtk\-Quadric\-Decimation}\label{vtkgraphics_vtkquadricdecimation}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Quadric\-Decimation is a filter to reduce the number of triangles in a triangle mesh, forming a good approximation to the original geometry. The input to vtk\-Quadric\-Decimation is a vtk\-Poly\-Data object, and only triangles are treated. If you desire to decimate polygonal meshes, first triangulate the polygons with vtk\-Triangle\-Filter.

The algorithm is based on repeated edge collapses until the requested mesh reduction is achieved. Edges are placed in a priority queue based on the \char`\"{}cost\char`\"{} to delete the edge. The cost is an approximate measure of error (distance to the original surface)--described by the so-\/called quadric error measure. The quadric error measure is associated with each vertex of the mesh and represents a matrix of planes incident on that vertex. The distance of the planes to the vertex is the error in the position of the vertex (originally the vertex error iz zero). As edges are deleted, the quadric error measure associated with the two end points of the edge are summed (this combines the plane equations) and an optimal collapse point can be computed. Edges connected to the collapse point are then reinserted into the queue after computing the new cost to delete them. The process continues until the desired reduction level is reached or topological constraints prevent further reduction. Note that this basic algorithm can be extended to higher dimensions by taking into account variation in attributes (i.\-e., scalars, vectors, and so on).

This paper is based on the work of Garland and Heckbert who first presented the quadric error measure at Siggraph '97 \char`\"{}\-Surface
 Simplification Using Quadric Error Metrics\char`\"{}. For details of the algorithm Michael Garland's Ph.\-D. thesis is also recommended. Hughues Hoppe's Vis '99 paper, \char`\"{}\-New Quadric Metric for Simplifying Meshes with Appearance
 Attributes\char`\"{} is also a good take on the subject especially as it pertains to the error metric applied to attributes.

.S\-E\-C\-T\-I\-O\-N Thanks Thanks to Bradley Lowekamp of the National Library of Medicine/\-N\-I\-H for contributing this class.

To create an instance of class vtk\-Quadric\-Decimation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkQuadricDecimation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Quadric\-Decimation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Quadric\-Decimation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Quadric\-Decimation = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Quadric\-Decimation = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Target\-Reduction (double )} -\/ Set/\-Get the desired reduction (expressed as a fraction of the original number of triangles). The actual reduction may be less depending on triangulation and topological constraints.  
\item {\ttfamily double = obj.\-Get\-Target\-Reduction\-Min\-Value ()} -\/ Set/\-Get the desired reduction (expressed as a fraction of the original number of triangles). The actual reduction may be less depending on triangulation and topological constraints.  
\item {\ttfamily double = obj.\-Get\-Target\-Reduction\-Max\-Value ()} -\/ Set/\-Get the desired reduction (expressed as a fraction of the original number of triangles). The actual reduction may be less depending on triangulation and topological constraints.  
\item {\ttfamily double = obj.\-Get\-Target\-Reduction ()} -\/ Set/\-Get the desired reduction (expressed as a fraction of the original number of triangles). The actual reduction may be less depending on triangulation and topological constraints.  
\item {\ttfamily obj.\-Set\-Attribute\-Error\-Metric (int )} -\/ Decide whether to include data attributes in the error metric. If off, then only geometric error is used to control the decimation. By default the attribute errors are off.  
\item {\ttfamily int = obj.\-Get\-Attribute\-Error\-Metric ()} -\/ Decide whether to include data attributes in the error metric. If off, then only geometric error is used to control the decimation. By default the attribute errors are off.  
\item {\ttfamily obj.\-Attribute\-Error\-Metric\-On ()} -\/ Decide whether to include data attributes in the error metric. If off, then only geometric error is used to control the decimation. By default the attribute errors are off.  
\item {\ttfamily obj.\-Attribute\-Error\-Metric\-Off ()} -\/ Decide whether to include data attributes in the error metric. If off, then only geometric error is used to control the decimation. By default the attribute errors are off.  
\item {\ttfamily obj.\-Set\-Scalars\-Attribute (int )} -\/ If attribute errors are to be included in the metric (i.\-e., Attribute\-Error\-Metric is on), then the following flags control which attributes are to be included in the error calculation. By default all of these are on.  
\item {\ttfamily int = obj.\-Get\-Scalars\-Attribute ()} -\/ If attribute errors are to be included in the metric (i.\-e., Attribute\-Error\-Metric is on), then the following flags control which attributes are to be included in the error calculation. By default all of these are on.  
\item {\ttfamily obj.\-Scalars\-Attribute\-On ()} -\/ If attribute errors are to be included in the metric (i.\-e., Attribute\-Error\-Metric is on), then the following flags control which attributes are to be included in the error calculation. By default all of these are on.  
\item {\ttfamily obj.\-Scalars\-Attribute\-Off ()} -\/ If attribute errors are to be included in the metric (i.\-e., Attribute\-Error\-Metric is on), then the following flags control which attributes are to be included in the error calculation. By default all of these are on.  
\item {\ttfamily obj.\-Set\-Vectors\-Attribute (int )} -\/ If attribute errors are to be included in the metric (i.\-e., Attribute\-Error\-Metric is on), then the following flags control which attributes are to be included in the error calculation. By default all of these are on.  
\item {\ttfamily int = obj.\-Get\-Vectors\-Attribute ()} -\/ If attribute errors are to be included in the metric (i.\-e., Attribute\-Error\-Metric is on), then the following flags control which attributes are to be included in the error calculation. By default all of these are on.  
\item {\ttfamily obj.\-Vectors\-Attribute\-On ()} -\/ If attribute errors are to be included in the metric (i.\-e., Attribute\-Error\-Metric is on), then the following flags control which attributes are to be included in the error calculation. By default all of these are on.  
\item {\ttfamily obj.\-Vectors\-Attribute\-Off ()} -\/ If attribute errors are to be included in the metric (i.\-e., Attribute\-Error\-Metric is on), then the following flags control which attributes are to be included in the error calculation. By default all of these are on.  
\item {\ttfamily obj.\-Set\-Normals\-Attribute (int )} -\/ If attribute errors are to be included in the metric (i.\-e., Attribute\-Error\-Metric is on), then the following flags control which attributes are to be included in the error calculation. By default all of these are on.  
\item {\ttfamily int = obj.\-Get\-Normals\-Attribute ()} -\/ If attribute errors are to be included in the metric (i.\-e., Attribute\-Error\-Metric is on), then the following flags control which attributes are to be included in the error calculation. By default all of these are on.  
\item {\ttfamily obj.\-Normals\-Attribute\-On ()} -\/ If attribute errors are to be included in the metric (i.\-e., Attribute\-Error\-Metric is on), then the following flags control which attributes are to be included in the error calculation. By default all of these are on.  
\item {\ttfamily obj.\-Normals\-Attribute\-Off ()} -\/ If attribute errors are to be included in the metric (i.\-e., Attribute\-Error\-Metric is on), then the following flags control which attributes are to be included in the error calculation. By default all of these are on.  
\item {\ttfamily obj.\-Set\-T\-Coords\-Attribute (int )} -\/ If attribute errors are to be included in the metric (i.\-e., Attribute\-Error\-Metric is on), then the following flags control which attributes are to be included in the error calculation. By default all of these are on.  
\item {\ttfamily int = obj.\-Get\-T\-Coords\-Attribute ()} -\/ If attribute errors are to be included in the metric (i.\-e., Attribute\-Error\-Metric is on), then the following flags control which attributes are to be included in the error calculation. By default all of these are on.  
\item {\ttfamily obj.\-T\-Coords\-Attribute\-On ()} -\/ If attribute errors are to be included in the metric (i.\-e., Attribute\-Error\-Metric is on), then the following flags control which attributes are to be included in the error calculation. By default all of these are on.  
\item {\ttfamily obj.\-T\-Coords\-Attribute\-Off ()} -\/ If attribute errors are to be included in the metric (i.\-e., Attribute\-Error\-Metric is on), then the following flags control which attributes are to be included in the error calculation. By default all of these are on.  
\item {\ttfamily obj.\-Set\-Tensors\-Attribute (int )} -\/ If attribute errors are to be included in the metric (i.\-e., Attribute\-Error\-Metric is on), then the following flags control which attributes are to be included in the error calculation. By default all of these are on.  
\item {\ttfamily int = obj.\-Get\-Tensors\-Attribute ()} -\/ If attribute errors are to be included in the metric (i.\-e., Attribute\-Error\-Metric is on), then the following flags control which attributes are to be included in the error calculation. By default all of these are on.  
\item {\ttfamily obj.\-Tensors\-Attribute\-On ()} -\/ If attribute errors are to be included in the metric (i.\-e., Attribute\-Error\-Metric is on), then the following flags control which attributes are to be included in the error calculation. By default all of these are on.  
\item {\ttfamily obj.\-Tensors\-Attribute\-Off ()} -\/ If attribute errors are to be included in the metric (i.\-e., Attribute\-Error\-Metric is on), then the following flags control which attributes are to be included in the error calculation. By default all of these are on.  
\item {\ttfamily obj.\-Set\-Scalars\-Weight (double )} -\/ Set/\-Get the scaling weight contribution of the attribute. These values are used to weight the contribution of the attributes towards the error metric.  
\item {\ttfamily obj.\-Set\-Vectors\-Weight (double )} -\/ Set/\-Get the scaling weight contribution of the attribute. These values are used to weight the contribution of the attributes towards the error metric.  
\item {\ttfamily obj.\-Set\-Normals\-Weight (double )} -\/ Set/\-Get the scaling weight contribution of the attribute. These values are used to weight the contribution of the attributes towards the error metric.  
\item {\ttfamily obj.\-Set\-T\-Coords\-Weight (double )} -\/ Set/\-Get the scaling weight contribution of the attribute. These values are used to weight the contribution of the attributes towards the error metric.  
\item {\ttfamily obj.\-Set\-Tensors\-Weight (double )} -\/ Set/\-Get the scaling weight contribution of the attribute. These values are used to weight the contribution of the attributes towards the error metric.  
\item {\ttfamily double = obj.\-Get\-Scalars\-Weight ()} -\/ Set/\-Get the scaling weight contribution of the attribute. These values are used to weight the contribution of the attributes towards the error metric.  
\item {\ttfamily double = obj.\-Get\-Vectors\-Weight ()} -\/ Set/\-Get the scaling weight contribution of the attribute. These values are used to weight the contribution of the attributes towards the error metric.  
\item {\ttfamily double = obj.\-Get\-Normals\-Weight ()} -\/ Set/\-Get the scaling weight contribution of the attribute. These values are used to weight the contribution of the attributes towards the error metric.  
\item {\ttfamily double = obj.\-Get\-T\-Coords\-Weight ()} -\/ Set/\-Get the scaling weight contribution of the attribute. These values are used to weight the contribution of the attributes towards the error metric.  
\item {\ttfamily double = obj.\-Get\-Tensors\-Weight ()} -\/ Set/\-Get the scaling weight contribution of the attribute. These values are used to weight the contribution of the attributes towards the error metric.  
\item {\ttfamily double = obj.\-Get\-Actual\-Reduction ()} -\/ Get the actual reduction. This value is only valid after the filter has executed.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkquantizepolydatapoints}{}\section{vtk\-Quantize\-Poly\-Data\-Points}\label{vtkgraphics_vtkquantizepolydatapoints}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Quantize\-Poly\-Data\-Points is a subclass of vtk\-Clean\-Poly\-Data and inherits the functionality of vtk\-Clean\-Poly\-Data with the addition that it quantizes the point coordinates before inserting into the point list. The user should set Q\-Factor to a positive value (0.\-25 by default) and all \{x,y,z\} coordinates will be quantized to that grain size.

A tolerance of zero is expected, though positive values may be used, the quantization will take place before the tolerance is applied.

To create an instance of class vtk\-Quantize\-Poly\-Data\-Points, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkQuantizePolyDataPoints
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Quantize\-Poly\-Data\-Points has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Quantize\-Poly\-Data\-Points class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Quantize\-Poly\-Data\-Points = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Quantize\-Poly\-Data\-Points = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Q\-Factor (double )} -\/ Specify quantization grain size. Default is 0.\-25  
\item {\ttfamily double = obj.\-Get\-Q\-Factor\-Min\-Value ()} -\/ Specify quantization grain size. Default is 0.\-25  
\item {\ttfamily double = obj.\-Get\-Q\-Factor\-Max\-Value ()} -\/ Specify quantization grain size. Default is 0.\-25  
\item {\ttfamily double = obj.\-Get\-Q\-Factor ()} -\/ Specify quantization grain size. Default is 0.\-25  
\item {\ttfamily obj.\-Operate\-On\-Point (double in\mbox{[}3\mbox{]}, double out\mbox{[}3\mbox{]})} -\/ Perform quantization on a point  
\item {\ttfamily obj.\-Operate\-On\-Bounds (double in\mbox{[}6\mbox{]}, double out\mbox{[}6\mbox{]})} -\/ Perform quantization on bounds  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkrandomattributegenerator}{}\section{vtk\-Random\-Attribute\-Generator}\label{vtkgraphics_vtkrandomattributegenerator}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Random\-Attribute\-Generator is a filter that creates random attributes including scalars, vectors, normals, tensors, texture coordinates and/or general data arrays. These attributes can be generated as point data, cell data or general field data. The generation of each component is normalized between a user-\/specified minimum and maximum value.

This filter provides that capability to specify the data type of the attributes, the range for each of the components, and the number of components. Note, however, that this flexibility only goes so far because some attributes (e.\-g., normals, vectors and tensors) are fixed in the number of components, and in the case of normals and tensors, are constrained in the values that some of the components can take (i.\-e., normals have magnitude one, and tensors are symmetric).

To create an instance of class vtk\-Random\-Attribute\-Generator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRandomAttributeGenerator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Random\-Attribute\-Generator has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Random\-Attribute\-Generator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Random\-Attribute\-Generator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Random\-Attribute\-Generator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Data\-Type (int )} -\/ Specify the type of array to create (all components of this array are of this type). This holds true for all arrays that are created.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Bit ()} -\/ Specify the type of array to create (all components of this array are of this type). This holds true for all arrays that are created.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Char ()} -\/ Specify the type of array to create (all components of this array are of this type). This holds true for all arrays that are created.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Unsigned\-Char ()} -\/ Specify the type of array to create (all components of this array are of this type). This holds true for all arrays that are created.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Short ()} -\/ Specify the type of array to create (all components of this array are of this type). This holds true for all arrays that are created.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Unsigned\-Short ()} -\/ Specify the type of array to create (all components of this array are of this type). This holds true for all arrays that are created.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Int ()} -\/ Specify the type of array to create (all components of this array are of this type). This holds true for all arrays that are created.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Unsigned\-Int ()} -\/ Specify the type of array to create (all components of this array are of this type). This holds true for all arrays that are created.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Long ()} -\/ Specify the type of array to create (all components of this array are of this type). This holds true for all arrays that are created.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Unsigned\-Long ()} -\/ Specify the type of array to create (all components of this array are of this type). This holds true for all arrays that are created.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Float ()} -\/ Specify the type of array to create (all components of this array are of this type). This holds true for all arrays that are created.  
\item {\ttfamily obj.\-Set\-Data\-Type\-To\-Double ()} -\/ Specify the type of array to create (all components of this array are of this type). This holds true for all arrays that are created.  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()} -\/ Specify the type of array to create (all components of this array are of this type). This holds true for all arrays that are created.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Components (int )} -\/ Specify the number of components to generate. This value only applies to those attribute types that take a variable number of components. For example, a vector is only three components so the number of components is not applicable; whereas a scalar may support multiple, varying number of components.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components\-Min\-Value ()} -\/ Specify the number of components to generate. This value only applies to those attribute types that take a variable number of components. For example, a vector is only three components so the number of components is not applicable; whereas a scalar may support multiple, varying number of components.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components\-Max\-Value ()} -\/ Specify the number of components to generate. This value only applies to those attribute types that take a variable number of components. For example, a vector is only three components so the number of components is not applicable; whereas a scalar may support multiple, varying number of components.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components ()} -\/ Specify the number of components to generate. This value only applies to those attribute types that take a variable number of components. For example, a vector is only three components so the number of components is not applicable; whereas a scalar may support multiple, varying number of components.  
\item {\ttfamily obj.\-Set\-Minimum\-Component\-Value (double )} -\/ Set the minimum component value. This applies to all data that is generated, although normals and tensors have internal constraints that must be observed.  
\item {\ttfamily double = obj.\-Get\-Minimum\-Component\-Value ()} -\/ Set the minimum component value. This applies to all data that is generated, although normals and tensors have internal constraints that must be observed.  
\item {\ttfamily obj.\-Set\-Maximum\-Component\-Value (double )} -\/ Set the maximum component value. This applies to all data that is generated, although normals and tensors have internal constraints that must be observed.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Component\-Value ()} -\/ Set the maximum component value. This applies to all data that is generated, although normals and tensors have internal constraints that must be observed.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Tuples (vtk\-Id\-Type )} -\/ Specify the number of tuples to generate. This value only applies when creating general field data. In all other cases (i.\-e., point data or cell data), the number of tuples is controlled by the number of points and cells, respectively.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Tuples\-Min\-Value ()} -\/ Specify the number of tuples to generate. This value only applies when creating general field data. In all other cases (i.\-e., point data or cell data), the number of tuples is controlled by the number of points and cells, respectively.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Tuples\-Max\-Value ()} -\/ Specify the number of tuples to generate. This value only applies when creating general field data. In all other cases (i.\-e., point data or cell data), the number of tuples is controlled by the number of points and cells, respectively.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Tuples ()} -\/ Specify the number of tuples to generate. This value only applies when creating general field data. In all other cases (i.\-e., point data or cell data), the number of tuples is controlled by the number of points and cells, respectively.  
\item {\ttfamily obj.\-Set\-Generate\-Point\-Scalars (int )} -\/ Indicate that point scalars are to be generated. Note that the specified number of components is used to create the scalar.  
\item {\ttfamily int = obj.\-Get\-Generate\-Point\-Scalars ()} -\/ Indicate that point scalars are to be generated. Note that the specified number of components is used to create the scalar.  
\item {\ttfamily obj.\-Generate\-Point\-Scalars\-On ()} -\/ Indicate that point scalars are to be generated. Note that the specified number of components is used to create the scalar.  
\item {\ttfamily obj.\-Generate\-Point\-Scalars\-Off ()} -\/ Indicate that point scalars are to be generated. Note that the specified number of components is used to create the scalar.  
\item {\ttfamily obj.\-Set\-Generate\-Point\-Vectors (int )} -\/ Indicate that point vectors are to be generated. Note that the number of components is always equal to three.  
\item {\ttfamily int = obj.\-Get\-Generate\-Point\-Vectors ()} -\/ Indicate that point vectors are to be generated. Note that the number of components is always equal to three.  
\item {\ttfamily obj.\-Generate\-Point\-Vectors\-On ()} -\/ Indicate that point vectors are to be generated. Note that the number of components is always equal to three.  
\item {\ttfamily obj.\-Generate\-Point\-Vectors\-Off ()} -\/ Indicate that point vectors are to be generated. Note that the number of components is always equal to three.  
\item {\ttfamily obj.\-Set\-Generate\-Point\-Normals (int )} -\/ Indicate that point normals are to be generated. Note that the number of components is always equal to three.  
\item {\ttfamily int = obj.\-Get\-Generate\-Point\-Normals ()} -\/ Indicate that point normals are to be generated. Note that the number of components is always equal to three.  
\item {\ttfamily obj.\-Generate\-Point\-Normals\-On ()} -\/ Indicate that point normals are to be generated. Note that the number of components is always equal to three.  
\item {\ttfamily obj.\-Generate\-Point\-Normals\-Off ()} -\/ Indicate that point normals are to be generated. Note that the number of components is always equal to three.  
\item {\ttfamily obj.\-Set\-Generate\-Point\-Tensors (int )} -\/ Indicate that point tensors are to be generated. Note that the number of components is always equal to nine.  
\item {\ttfamily int = obj.\-Get\-Generate\-Point\-Tensors ()} -\/ Indicate that point tensors are to be generated. Note that the number of components is always equal to nine.  
\item {\ttfamily obj.\-Generate\-Point\-Tensors\-On ()} -\/ Indicate that point tensors are to be generated. Note that the number of components is always equal to nine.  
\item {\ttfamily obj.\-Generate\-Point\-Tensors\-Off ()} -\/ Indicate that point tensors are to be generated. Note that the number of components is always equal to nine.  
\item {\ttfamily obj.\-Set\-Generate\-Point\-T\-Coords (int )} -\/ Indicate that point texture coordinates are to be generated. Note that the specified number of components is used to create the texture coordinates (but must range between one and three).  
\item {\ttfamily int = obj.\-Get\-Generate\-Point\-T\-Coords ()} -\/ Indicate that point texture coordinates are to be generated. Note that the specified number of components is used to create the texture coordinates (but must range between one and three).  
\item {\ttfamily obj.\-Generate\-Point\-T\-Coords\-On ()} -\/ Indicate that point texture coordinates are to be generated. Note that the specified number of components is used to create the texture coordinates (but must range between one and three).  
\item {\ttfamily obj.\-Generate\-Point\-T\-Coords\-Off ()} -\/ Indicate that point texture coordinates are to be generated. Note that the specified number of components is used to create the texture coordinates (but must range between one and three).  
\item {\ttfamily obj.\-Set\-Generate\-Point\-Array (int )} -\/ Indicate that an arbitrary point array is to be generated. Note that the specified number of components is used to create the array.  
\item {\ttfamily int = obj.\-Get\-Generate\-Point\-Array ()} -\/ Indicate that an arbitrary point array is to be generated. Note that the specified number of components is used to create the array.  
\item {\ttfamily obj.\-Generate\-Point\-Array\-On ()} -\/ Indicate that an arbitrary point array is to be generated. Note that the specified number of components is used to create the array.  
\item {\ttfamily obj.\-Generate\-Point\-Array\-Off ()} -\/ Indicate that an arbitrary point array is to be generated. Note that the specified number of components is used to create the array.  
\item {\ttfamily obj.\-Set\-Generate\-Cell\-Scalars (int )} -\/ Indicate that cell scalars are to be generated. Note that the specified number of components is used to create the scalar.  
\item {\ttfamily int = obj.\-Get\-Generate\-Cell\-Scalars ()} -\/ Indicate that cell scalars are to be generated. Note that the specified number of components is used to create the scalar.  
\item {\ttfamily obj.\-Generate\-Cell\-Scalars\-On ()} -\/ Indicate that cell scalars are to be generated. Note that the specified number of components is used to create the scalar.  
\item {\ttfamily obj.\-Generate\-Cell\-Scalars\-Off ()} -\/ Indicate that cell scalars are to be generated. Note that the specified number of components is used to create the scalar.  
\item {\ttfamily obj.\-Set\-Generate\-Cell\-Vectors (int )} -\/ Indicate that cell vectors are to be generated. Note that the number of components is always equal to three.  
\item {\ttfamily int = obj.\-Get\-Generate\-Cell\-Vectors ()} -\/ Indicate that cell vectors are to be generated. Note that the number of components is always equal to three.  
\item {\ttfamily obj.\-Generate\-Cell\-Vectors\-On ()} -\/ Indicate that cell vectors are to be generated. Note that the number of components is always equal to three.  
\item {\ttfamily obj.\-Generate\-Cell\-Vectors\-Off ()} -\/ Indicate that cell vectors are to be generated. Note that the number of components is always equal to three.  
\item {\ttfamily obj.\-Set\-Generate\-Cell\-Normals (int )} -\/ Indicate that cell normals are to be generated. Note that the number of components is always equal to three.  
\item {\ttfamily int = obj.\-Get\-Generate\-Cell\-Normals ()} -\/ Indicate that cell normals are to be generated. Note that the number of components is always equal to three.  
\item {\ttfamily obj.\-Generate\-Cell\-Normals\-On ()} -\/ Indicate that cell normals are to be generated. Note that the number of components is always equal to three.  
\item {\ttfamily obj.\-Generate\-Cell\-Normals\-Off ()} -\/ Indicate that cell normals are to be generated. Note that the number of components is always equal to three.  
\item {\ttfamily obj.\-Set\-Generate\-Cell\-Tensors (int )} -\/ Indicate that cell tensors are to be generated. Note that the number of components is always equal to nine.  
\item {\ttfamily int = obj.\-Get\-Generate\-Cell\-Tensors ()} -\/ Indicate that cell tensors are to be generated. Note that the number of components is always equal to nine.  
\item {\ttfamily obj.\-Generate\-Cell\-Tensors\-On ()} -\/ Indicate that cell tensors are to be generated. Note that the number of components is always equal to nine.  
\item {\ttfamily obj.\-Generate\-Cell\-Tensors\-Off ()} -\/ Indicate that cell tensors are to be generated. Note that the number of components is always equal to nine.  
\item {\ttfamily obj.\-Set\-Generate\-Cell\-T\-Coords (int )} -\/ Indicate that cell texture coordinates are to be generated. Note that the specified number of components is used to create the texture coordinates (but must range between one and three).  
\item {\ttfamily int = obj.\-Get\-Generate\-Cell\-T\-Coords ()} -\/ Indicate that cell texture coordinates are to be generated. Note that the specified number of components is used to create the texture coordinates (but must range between one and three).  
\item {\ttfamily obj.\-Generate\-Cell\-T\-Coords\-On ()} -\/ Indicate that cell texture coordinates are to be generated. Note that the specified number of components is used to create the texture coordinates (but must range between one and three).  
\item {\ttfamily obj.\-Generate\-Cell\-T\-Coords\-Off ()} -\/ Indicate that cell texture coordinates are to be generated. Note that the specified number of components is used to create the texture coordinates (but must range between one and three).  
\item {\ttfamily obj.\-Set\-Generate\-Cell\-Array (int )} -\/ Indicate that an arbitrary cell array is to be generated. Note that the specified number of components is used to create the array.  
\item {\ttfamily int = obj.\-Get\-Generate\-Cell\-Array ()} -\/ Indicate that an arbitrary cell array is to be generated. Note that the specified number of components is used to create the array.  
\item {\ttfamily obj.\-Generate\-Cell\-Array\-On ()} -\/ Indicate that an arbitrary cell array is to be generated. Note that the specified number of components is used to create the array.  
\item {\ttfamily obj.\-Generate\-Cell\-Array\-Off ()} -\/ Indicate that an arbitrary cell array is to be generated. Note that the specified number of components is used to create the array.  
\item {\ttfamily obj.\-Set\-Generate\-Field\-Array (int )} -\/ Indicate that an arbitrary field data array is to be generated. Note that the specified number of components is used to create the scalar.  
\item {\ttfamily int = obj.\-Get\-Generate\-Field\-Array ()} -\/ Indicate that an arbitrary field data array is to be generated. Note that the specified number of components is used to create the scalar.  
\item {\ttfamily obj.\-Generate\-Field\-Array\-On ()} -\/ Indicate that an arbitrary field data array is to be generated. Note that the specified number of components is used to create the scalar.  
\item {\ttfamily obj.\-Generate\-Field\-Array\-Off ()} -\/ Indicate that an arbitrary field data array is to be generated. Note that the specified number of components is used to create the scalar.  
\item {\ttfamily obj.\-Generate\-All\-Point\-Data\-On ()} -\/ Convenience methods for generating data\-: all data, all point data, or all cell data. For example, if all data is enabled, then all point, cell and field data is generated. If all point data is enabled, then point scalars, vectors, normals, tensors, tcoords, and a data array are produced.  
\item {\ttfamily obj.\-Generate\-All\-Point\-Data\-Off ()} -\/ Convenience methods for generating data\-: all data, all point data, or all cell data. For example, if all data is enabled, then all point, cell and field data is generated. If all point data is enabled, then point scalars, vectors, normals, tensors, tcoords, and a data array are produced.  
\item {\ttfamily obj.\-Generate\-All\-Cell\-Data\-On ()} -\/ Convenience methods for generating data\-: all data, all point data, or all cell data. For example, if all data is enabled, then all point, cell and field data is generated. If all point data is enabled, then point scalars, vectors, normals, tensors, tcoords, and a data array are produced.  
\item {\ttfamily obj.\-Generate\-All\-Cell\-Data\-Off ()} -\/ Convenience methods for generating data\-: all data, all point data, or all cell data. For example, if all data is enabled, then all point, cell and field data is generated. If all point data is enabled, then point scalars, vectors, normals, tensors, tcoords, and a data array are produced.  
\item {\ttfamily obj.\-Generate\-All\-Data\-On ()} -\/ Convenience methods for generating data\-: all data, all point data, or all cell data. For example, if all data is enabled, then all point, cell and field data is generated. If all point data is enabled, then point scalars, vectors, normals, tensors, tcoords, and a data array are produced.  
\item {\ttfamily obj.\-Generate\-All\-Data\-Off ()}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkrearrangefields}{}\section{vtk\-Rearrange\-Fields}\label{vtkgraphics_vtkrearrangefields}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Rearrange\-Fields is used to copy/move fields (vtk\-Data\-Arrays) between data object's field data, point data and cell data. To specify which fields are copied/moved, the user adds operations. There are two types of operations\-: 1. the type which copies/moves an attribute's data (i.\-e. the field will be copied but will not be an attribute in the target), 2. the type which copies/moves fields by name. For example\-: \begin{DoxyVerb} rf->AddOperation(vtkRearrangeFields::COPY, "foo", 
                  vtkRearrangeFields::DATA_OBJECT, 
                  vtkRearrangeFields::POINT_DATA);\end{DoxyVerb}
 adds an operation which copies a field (data array) called foo from the data object's field data to point data. From Tcl, the same operation can be added as follows\-: \begin{DoxyVerb} rf AddOperation COPY foo DATA_OBJECT POINT_DATA\end{DoxyVerb}
 The same can be done using Python and Java bindings by passing strings as arguments. \begin{DoxyVerb} Operation types: COPY, MOVE
 AttributeTypes: SCALARS, VECTORS, NORMALS, TCOORDS, TENSORS
 Field data locations: DATA_OBJECT, POINT_DATA, CELL_DATA\end{DoxyVerb}


To create an instance of class vtk\-Rearrange\-Fields, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRearrangeFields
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Rearrange\-Fields has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Rearrange\-Fields class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Rearrange\-Fields = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Rearrange\-Fields = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Add\-Operation (int operation\-Type, int attribute\-Type, int from\-Field\-Loc, int to\-Field\-Loc)} -\/ Add an operation which copies an attribute's field (data array) from one field data to another. Returns an operation id which can later be used to remove the operation.  
\item {\ttfamily int = obj.\-Add\-Operation (int operation\-Type, string name, int from\-Field\-Loc, int to\-Field\-Loc)} -\/ Add an operation which copies a field (data array) from one field data to another. Returns an operation id which can later be used to remove the operation.  
\item {\ttfamily int = obj.\-Add\-Operation (string operation\-Type, string attribute\-Type, string from\-Field\-Loc, string to\-Field\-Loc)} -\/ Helper method used by other language bindings. Allows the caller to specify arguments as strings instead of enums.\-Returns an operation id which can later be used to remove the operation.  
\item {\ttfamily int = obj.\-Remove\-Operation (int operation\-Id)} -\/ Remove an operation with the given id.  
\item {\ttfamily int = obj.\-Remove\-Operation (int operation\-Type, int attribute\-Type, int from\-Field\-Loc, int to\-Field\-Loc)} -\/ Remove an operation with the given signature. See Add\-Operation for details.  
\item {\ttfamily int = obj.\-Remove\-Operation (int operation\-Type, string name, int from\-Field\-Loc, int to\-Field\-Loc)} -\/ Remove an operation with the given signature. See Add\-Operation for details.  
\item {\ttfamily int = obj.\-Remove\-Operation (string operation\-Type, string attribute\-Type, string from\-Field\-Loc, string to\-Field\-Loc)} -\/ Remove an operation with the given signature. See Add\-Operation for details.  
\item {\ttfamily obj.\-Remove\-All\-Operations ()}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkrectangularbuttonsource}{}\section{vtk\-Rectangular\-Button\-Source}\label{vtkgraphics_vtkrectangularbuttonsource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Rectangular\-Button\-Source creates a rectangular shaped button with texture coordinates suitable for application of a texture map. This provides a way to make nice looking 3\-D buttons. The buttons are represented as vtk\-Poly\-Data that includes texture coordinates and normals. The button lies in the x-\/y plane.

To use this class you must define its width, height and length. These measurements are all taken with respect to the shoulder of the button. The shoulder is defined as follows. Imagine a box sitting on the floor. The distance from the floor to the top of the box is the depth; the other directions are the length (x-\/direction) and height (y-\/direction). In this particular widget the box can have a smaller bottom than top. The ratio in size between bottom and top is called the box ratio (by default=1.\-0). The ratio of the texture region to the shoulder region is the texture ratio. And finally the texture region may be out of plane compared to the shoulder. The texture height ratio controls this.

To create an instance of class vtk\-Rectangular\-Button\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRectangularButtonSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Rectangular\-Button\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Rectangular\-Button\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Rectangular\-Button\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Rectangular\-Button\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Width (double )} -\/ Set/\-Get the width of the button.  
\item {\ttfamily double = obj.\-Get\-Width\-Min\-Value ()} -\/ Set/\-Get the width of the button.  
\item {\ttfamily double = obj.\-Get\-Width\-Max\-Value ()} -\/ Set/\-Get the width of the button.  
\item {\ttfamily double = obj.\-Get\-Width ()} -\/ Set/\-Get the width of the button.  
\item {\ttfamily obj.\-Set\-Height (double )} -\/ Set/\-Get the height of the button.  
\item {\ttfamily double = obj.\-Get\-Height\-Min\-Value ()} -\/ Set/\-Get the height of the button.  
\item {\ttfamily double = obj.\-Get\-Height\-Max\-Value ()} -\/ Set/\-Get the height of the button.  
\item {\ttfamily double = obj.\-Get\-Height ()} -\/ Set/\-Get the height of the button.  
\item {\ttfamily obj.\-Set\-Depth (double )} -\/ Set/\-Get the depth of the button (the z-\/eliipsoid axis length).  
\item {\ttfamily double = obj.\-Get\-Depth\-Min\-Value ()} -\/ Set/\-Get the depth of the button (the z-\/eliipsoid axis length).  
\item {\ttfamily double = obj.\-Get\-Depth\-Max\-Value ()} -\/ Set/\-Get the depth of the button (the z-\/eliipsoid axis length).  
\item {\ttfamily double = obj.\-Get\-Depth ()} -\/ Set/\-Get the depth of the button (the z-\/eliipsoid axis length).  
\item {\ttfamily obj.\-Set\-Box\-Ratio (double )} -\/ Set/\-Get the ratio of the bottom of the button with the shoulder region. Numbers greater than one produce buttons with a wider bottom than shoulder; ratios less than one produce buttons that have a wider shoulder than bottom.  
\item {\ttfamily double = obj.\-Get\-Box\-Ratio\-Min\-Value ()} -\/ Set/\-Get the ratio of the bottom of the button with the shoulder region. Numbers greater than one produce buttons with a wider bottom than shoulder; ratios less than one produce buttons that have a wider shoulder than bottom.  
\item {\ttfamily double = obj.\-Get\-Box\-Ratio\-Max\-Value ()} -\/ Set/\-Get the ratio of the bottom of the button with the shoulder region. Numbers greater than one produce buttons with a wider bottom than shoulder; ratios less than one produce buttons that have a wider shoulder than bottom.  
\item {\ttfamily double = obj.\-Get\-Box\-Ratio ()} -\/ Set/\-Get the ratio of the bottom of the button with the shoulder region. Numbers greater than one produce buttons with a wider bottom than shoulder; ratios less than one produce buttons that have a wider shoulder than bottom.  
\item {\ttfamily obj.\-Set\-Texture\-Ratio (double )} -\/ Set/\-Get the ratio of the texture region to the shoulder region. This number must be 0$<$=tr$<$=1. If the texture style is to fit the image, then satisfying the texture ratio may only be possible in one of the two directions (length or width) depending on the dimensions of the texture.  
\item {\ttfamily double = obj.\-Get\-Texture\-Ratio\-Min\-Value ()} -\/ Set/\-Get the ratio of the texture region to the shoulder region. This number must be 0$<$=tr$<$=1. If the texture style is to fit the image, then satisfying the texture ratio may only be possible in one of the two directions (length or width) depending on the dimensions of the texture.  
\item {\ttfamily double = obj.\-Get\-Texture\-Ratio\-Max\-Value ()} -\/ Set/\-Get the ratio of the texture region to the shoulder region. This number must be 0$<$=tr$<$=1. If the texture style is to fit the image, then satisfying the texture ratio may only be possible in one of the two directions (length or width) depending on the dimensions of the texture.  
\item {\ttfamily double = obj.\-Get\-Texture\-Ratio ()} -\/ Set/\-Get the ratio of the texture region to the shoulder region. This number must be 0$<$=tr$<$=1. If the texture style is to fit the image, then satisfying the texture ratio may only be possible in one of the two directions (length or width) depending on the dimensions of the texture.  
\item {\ttfamily obj.\-Set\-Texture\-Height\-Ratio (double )} -\/ Set/\-Get the ratio of the height of the texture region to the shoulder height. Values greater than 1.\-0 yield convex buttons with the texture region raised above the shoulder. Values less than 1.\-0 yield concave buttons with the texture region below the shoulder.  
\item {\ttfamily double = obj.\-Get\-Texture\-Height\-Ratio\-Min\-Value ()} -\/ Set/\-Get the ratio of the height of the texture region to the shoulder height. Values greater than 1.\-0 yield convex buttons with the texture region raised above the shoulder. Values less than 1.\-0 yield concave buttons with the texture region below the shoulder.  
\item {\ttfamily double = obj.\-Get\-Texture\-Height\-Ratio\-Max\-Value ()} -\/ Set/\-Get the ratio of the height of the texture region to the shoulder height. Values greater than 1.\-0 yield convex buttons with the texture region raised above the shoulder. Values less than 1.\-0 yield concave buttons with the texture region below the shoulder.  
\item {\ttfamily double = obj.\-Get\-Texture\-Height\-Ratio ()} -\/ Set/\-Get the ratio of the height of the texture region to the shoulder height. Values greater than 1.\-0 yield convex buttons with the texture region raised above the shoulder. Values less than 1.\-0 yield concave buttons with the texture region below the shoulder.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkrectilineargridclip}{}\section{vtk\-Rectilinear\-Grid\-Clip}\label{vtkgraphics_vtkrectilineargridclip}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Rectilinear\-Grid\-Clip will make an image smaller. The output must have an image extent which is the subset of the input. The filter has two modes of operation\-: 1\-: By default, the data is not copied in this filter. Only the whole extent is modified. 2\-: If Clip\-Data\-On is set, then you will get no more that the clipped extent.

To create an instance of class vtk\-Rectilinear\-Grid\-Clip, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRectilinearGridClip
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Rectilinear\-Grid\-Clip has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Clip class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Rectilinear\-Grid\-Clip = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Rectilinear\-Grid\-Clip = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Output\-Whole\-Extent (int extent\mbox{[}6\mbox{]}, vtk\-Information out\-Info)} -\/ The whole extent of the output has to be set explicitly.  
\item {\ttfamily obj.\-Set\-Output\-Whole\-Extent (int min\-X, int max\-X, int min\-Y, int max\-Y, int min\-Z, int max\-Z)} -\/ The whole extent of the output has to be set explicitly.  
\item {\ttfamily obj.\-Get\-Output\-Whole\-Extent (int extent\mbox{[}6\mbox{]})} -\/ The whole extent of the output has to be set explicitly.  
\item {\ttfamily obj.\-Reset\-Output\-Whole\-Extent ()}  
\item {\ttfamily obj.\-Set\-Clip\-Data (int )} -\/ By default, Clip\-Data is off, and only the Whole\-Extent is modified. the data's extent may actually be larger. When this flag is on, the data extent will be no more than the Output\-Whole\-Extent.  
\item {\ttfamily int = obj.\-Get\-Clip\-Data ()} -\/ By default, Clip\-Data is off, and only the Whole\-Extent is modified. the data's extent may actually be larger. When this flag is on, the data extent will be no more than the Output\-Whole\-Extent.  
\item {\ttfamily obj.\-Clip\-Data\-On ()} -\/ By default, Clip\-Data is off, and only the Whole\-Extent is modified. the data's extent may actually be larger. When this flag is on, the data extent will be no more than the Output\-Whole\-Extent.  
\item {\ttfamily obj.\-Clip\-Data\-Off ()} -\/ By default, Clip\-Data is off, and only the Whole\-Extent is modified. the data's extent may actually be larger. When this flag is on, the data extent will be no more than the Output\-Whole\-Extent.  
\item {\ttfamily obj.\-Set\-Output\-Whole\-Extent (int piece, int num\-Pieces)} -\/ Hack set output by piece  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkrectilineargridgeometryfilter}{}\section{vtk\-Rectilinear\-Grid\-Geometry\-Filter}\label{vtkgraphics_vtkrectilineargridgeometryfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Rectilinear\-Grid\-Geometry\-Filter is a filter that extracts geometry from a rectilinear grid. By specifying appropriate i-\/j-\/k indices, it is possible to extract a point, a curve, a surface, or a \char`\"{}volume\char`\"{}. The volume is actually a (n x m x o) region of points.

The extent specification is zero-\/offset. That is, the first k-\/plane in a 50x50x50 rectilinear grid is given by (0,49, 0,49, 0,0).

To create an instance of class vtk\-Rectilinear\-Grid\-Geometry\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRectilinearGridGeometryFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Rectilinear\-Grid\-Geometry\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Geometry\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Rectilinear\-Grid\-Geometry\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Rectilinear\-Grid\-Geometry\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj. Get\-Extent ()} -\/ Get the extent in topological coordinate range (imin,imax, jmin,jmax, kmin,kmax).  
\item {\ttfamily obj.\-Set\-Extent (int i\-Min, int i\-Max, int j\-Min, int j\-Max, int k\-Min, int k\-Max)} -\/ Specify (imin,imax, jmin,jmax, kmin,kmax) indices.  
\item {\ttfamily obj.\-Set\-Extent (int extent\mbox{[}6\mbox{]})} -\/ Specify (imin,imax, jmin,jmax, kmin,kmax) indices in array form.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkrectilineargridtotetrahedra}{}\section{vtk\-Rectilinear\-Grid\-To\-Tetrahedra}\label{vtkgraphics_vtkrectilineargridtotetrahedra}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Rectilinear\-Grid\-To\-Tetrahedra forms a mesh of Tetrahedra from a vtk\-Rectilinear\-Grid. The tetrahedra can be 5 per cell, 6 per cell, or a mixture of 5 or 12 per cell. The resulting mesh is consistent, meaning that there are no edge crossings and that each tetrahedron face is shared by two tetrahedra, except those tetrahedra on the boundary. All tetrahedra are right handed.

Note that 12 tetrahedra per cell means adding a point in the center of the cell.

In order to subdivide some cells into 5 and some cells into 12 tetrahedra\-: Set\-Tetra\-Per\-Cell\-To5\-And12(); Set the Scalars of the Input Rectilinear\-Grid to be 5 or 12 depending on what you want per cell of the Rectilinear\-Grid.

If you set Remember\-Voxel\-Id, the scalars of the tetrahedron will be set to the Id of the Cell in the Rectilinear\-Grid from which the tetrahedron came.

.S\-E\-C\-T\-I\-O\-N Thanks This class was developed by Samson J. Timoner of the M\-I\-T Artificial Intelligence Laboratory

To create an instance of class vtk\-Rectilinear\-Grid\-To\-Tetrahedra, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRectilinearGridToTetrahedra
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Rectilinear\-Grid\-To\-Tetrahedra has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-To\-Tetrahedra class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Rectilinear\-Grid\-To\-Tetrahedra = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Rectilinear\-Grid\-To\-Tetrahedra = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Tetra\-Per\-Cell\-To5 ()} -\/ Set the method to divide each cell (voxel) in the Rectilinear\-Grid into tetrahedra.  
\item {\ttfamily obj.\-Set\-Tetra\-Per\-Cell\-To6 ()} -\/ Set the method to divide each cell (voxel) in the Rectilinear\-Grid into tetrahedra.  
\item {\ttfamily obj.\-Set\-Tetra\-Per\-Cell\-To12 ()} -\/ Set the method to divide each cell (voxel) in the Rectilinear\-Grid into tetrahedra.  
\item {\ttfamily obj.\-Set\-Tetra\-Per\-Cell\-To5\-And12 ()} -\/ Set the method to divide each cell (voxel) in the Rectilinear\-Grid into tetrahedra.  
\item {\ttfamily obj.\-Set\-Tetra\-Per\-Cell (int )} -\/ Set the method to divide each cell (voxel) in the Rectilinear\-Grid into tetrahedra.  
\item {\ttfamily int = obj.\-Get\-Tetra\-Per\-Cell ()} -\/ Set the method to divide each cell (voxel) in the Rectilinear\-Grid into tetrahedra.  
\item {\ttfamily obj.\-Set\-Remember\-Voxel\-Id (int )} -\/ Should the tetrahedra have scalar data indicating which Voxel they came from in the vtk\-Rectilinear\-Grid?  
\item {\ttfamily int = obj.\-Get\-Remember\-Voxel\-Id ()} -\/ Should the tetrahedra have scalar data indicating which Voxel they came from in the vtk\-Rectilinear\-Grid?  
\item {\ttfamily obj.\-Remember\-Voxel\-Id\-On ()} -\/ Should the tetrahedra have scalar data indicating which Voxel they came from in the vtk\-Rectilinear\-Grid?  
\item {\ttfamily obj.\-Remember\-Voxel\-Id\-Off ()} -\/ Should the tetrahedra have scalar data indicating which Voxel they came from in the vtk\-Rectilinear\-Grid?  
\item {\ttfamily obj.\-Set\-Input (double Extent\mbox{[}3\mbox{]}, double Spacing\mbox{[}3\mbox{]}, double tol)} -\/ This function for convenience for creating a Rectilinear Grid If Spacing does not fit evenly into extent, the last cell will have a different width (or height or depth). If Extent\mbox{[}i\mbox{]}/\-Spacing\mbox{[}i\mbox{]} is within tol of an integer, then assume the programmer meant an integer for direction i.  
\item {\ttfamily obj.\-Set\-Input (double Extent\-X, double Extent\-Y, double Extent\-Z, double Spacing\-X, double Spacing\-Y, double Spacing\-Z, double tol)} -\/ This version of the function for the wrappers  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkrectilinearsynchronizedtemplates}{}\section{vtk\-Rectilinear\-Synchronized\-Templates}\label{vtkgraphics_vtkrectilinearsynchronizedtemplates}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Rectilinear\-Synchronized\-Templates is a 3\-D implementation (for rectilinear grids) of the synchronized template algorithm. Note that vtk\-Contour\-Filter will automatically use this class when appropriate.

To create an instance of class vtk\-Rectilinear\-Synchronized\-Templates, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRectilinearSynchronizedTemplates
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Rectilinear\-Synchronized\-Templates has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Synchronized\-Templates class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Rectilinear\-Synchronized\-Templates = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Rectilinear\-Synchronized\-Templates = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Because we delegate to vtk\-Contour\-Values  
\item {\ttfamily obj.\-Set\-Compute\-Normals (int )} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily int = obj.\-Get\-Compute\-Normals ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Normals\-On ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Normals\-Off ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Set\-Compute\-Gradients (int )} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily int = obj.\-Get\-Compute\-Gradients ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Gradients\-On ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Gradients\-Off ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Set\-Compute\-Scalars (int )} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily int = obj.\-Get\-Compute\-Scalars ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Compute\-Scalars\-On ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Compute\-Scalars\-Off ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Set\-Value (int i, double value)} -\/ Get the ith contour value.  
\item {\ttfamily double = obj.\-Get\-Value (int i)} -\/ Get a pointer to an array of contour values. There will be Get\-Number\-Of\-Contours() values in the list.  
\item {\ttfamily obj.\-Get\-Values (double contour\-Values)} -\/ Set the number of contours to place into the list. You only really need to use this method to reduce list size. The method Set\-Value() will automatically increase list size as needed.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Contours (int number)} -\/ Get the number of contours in the list of contour values.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Contours ()} -\/ Generate num\-Contours equally spaced contour values between specified range. Contour values will include min/max range values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\mbox{[}2\mbox{]})} -\/ Generate num\-Contours equally spaced contour values between specified range. Contour values will include min/max range values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\-Start, double range\-End)} -\/ Needed by templated functions.  
\item {\ttfamily obj.\-Set\-Array\-Component (int )} -\/ Set/get which component of the scalar array to contour on; defaults to 0.  
\item {\ttfamily int = obj.\-Get\-Array\-Component ()} -\/ Set/get which component of the scalar array to contour on; defaults to 0.  
\item {\ttfamily obj.\-Compute\-Spacing (vtk\-Rectilinear\-Grid data, int i, int j, int k, int extent\mbox{[}6\mbox{]}, double spacing\mbox{[}6\mbox{]})} -\/ Compute the spacing between this point and its 6 neighbors. This method needs to be public so it can be accessed from a templated function.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkrecursivedividingcubes}{}\section{vtk\-Recursive\-Dividing\-Cubes}\label{vtkgraphics_vtkrecursivedividingcubes}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Recursive\-Dividing\-Cubes is a filter that generates points lying on a surface of constant scalar value (i.\-e., an isosurface). Dense point clouds (i.\-e., at screen resolution) will appear as a surface. Less dense clouds can be used as a source to generate streamlines or to generate \char`\"{}transparent\char`\"{} surfaces.

This implementation differs from vtk\-Dividing\-Cubes in that it uses a recursive procedure. In many cases this can result in generating more points than the procedural implementation of vtk\-Dividing\-Cubes. This is because the recursive procedure divides voxels by multiples of powers of two. This can over-\/constrain subdivision. One of the advantages of the recursive technique is that the recursion is terminated earlier, which in some cases can be more efficient.

To create an instance of class vtk\-Recursive\-Dividing\-Cubes, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRecursiveDividingCubes
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Recursive\-Dividing\-Cubes has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Recursive\-Dividing\-Cubes class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Recursive\-Dividing\-Cubes = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Recursive\-Dividing\-Cubes = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Value (double )} -\/ Set isosurface value.  
\item {\ttfamily double = obj.\-Get\-Value ()} -\/ Set isosurface value.  
\item {\ttfamily obj.\-Set\-Distance (double )} -\/ Specify sub-\/voxel size at which to generate point.  
\item {\ttfamily double = obj.\-Get\-Distance\-Min\-Value ()} -\/ Specify sub-\/voxel size at which to generate point.  
\item {\ttfamily double = obj.\-Get\-Distance\-Max\-Value ()} -\/ Specify sub-\/voxel size at which to generate point.  
\item {\ttfamily double = obj.\-Get\-Distance ()} -\/ Specify sub-\/voxel size at which to generate point.  
\item {\ttfamily obj.\-Set\-Increment (int )} -\/ Every \char`\"{}\-Increment\char`\"{} point is added to the list of points. This parameter, if set to a large value, can be used to limit the number of points while retaining good accuracy.  
\item {\ttfamily int = obj.\-Get\-Increment\-Min\-Value ()} -\/ Every \char`\"{}\-Increment\char`\"{} point is added to the list of points. This parameter, if set to a large value, can be used to limit the number of points while retaining good accuracy.  
\item {\ttfamily int = obj.\-Get\-Increment\-Max\-Value ()} -\/ Every \char`\"{}\-Increment\char`\"{} point is added to the list of points. This parameter, if set to a large value, can be used to limit the number of points while retaining good accuracy.  
\item {\ttfamily int = obj.\-Get\-Increment ()} -\/ Every \char`\"{}\-Increment\char`\"{} point is added to the list of points. This parameter, if set to a large value, can be used to limit the number of points while retaining good accuracy.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkreflectionfilter}{}\section{vtk\-Reflection\-Filter}\label{vtkgraphics_vtkreflectionfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Reflection\-Filter reflects a data set across one of the planes formed by the data set's bounding box. Since it converts data sets into unstructured grids, it is not effeicient for structured data sets.

To create an instance of class vtk\-Reflection\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkReflectionFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Reflection\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Reflection\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Reflection\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Reflection\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Plane (int )} -\/ Set the normal of the plane to use as mirror.  
\item {\ttfamily int = obj.\-Get\-Plane\-Min\-Value ()} -\/ Set the normal of the plane to use as mirror.  
\item {\ttfamily int = obj.\-Get\-Plane\-Max\-Value ()} -\/ Set the normal of the plane to use as mirror.  
\item {\ttfamily int = obj.\-Get\-Plane ()} -\/ Set the normal of the plane to use as mirror.  
\item {\ttfamily obj.\-Set\-Plane\-To\-X ()} -\/ Set the normal of the plane to use as mirror.  
\item {\ttfamily obj.\-Set\-Plane\-To\-Y ()} -\/ Set the normal of the plane to use as mirror.  
\item {\ttfamily obj.\-Set\-Plane\-To\-Z ()} -\/ Set the normal of the plane to use as mirror.  
\item {\ttfamily obj.\-Set\-Plane\-To\-X\-Min ()} -\/ Set the normal of the plane to use as mirror.  
\item {\ttfamily obj.\-Set\-Plane\-To\-Y\-Min ()} -\/ Set the normal of the plane to use as mirror.  
\item {\ttfamily obj.\-Set\-Plane\-To\-Z\-Min ()} -\/ Set the normal of the plane to use as mirror.  
\item {\ttfamily obj.\-Set\-Plane\-To\-X\-Max ()} -\/ Set the normal of the plane to use as mirror.  
\item {\ttfamily obj.\-Set\-Plane\-To\-Y\-Max ()} -\/ Set the normal of the plane to use as mirror.  
\item {\ttfamily obj.\-Set\-Plane\-To\-Z\-Max ()} -\/ Set the normal of the plane to use as mirror.  
\item {\ttfamily obj.\-Set\-Center (double )} -\/ If the reflection plane is set to X, Y or Z, this variable is use to set the position of the plane.  
\item {\ttfamily double = obj.\-Get\-Center ()} -\/ If the reflection plane is set to X, Y or Z, this variable is use to set the position of the plane.  
\item {\ttfamily obj.\-Set\-Copy\-Input (int )} -\/ If on (the default), copy the input geometry to the output. If off, the output will only contain the reflection.  
\item {\ttfamily int = obj.\-Get\-Copy\-Input ()} -\/ If on (the default), copy the input geometry to the output. If off, the output will only contain the reflection.  
\item {\ttfamily obj.\-Copy\-Input\-On ()} -\/ If on (the default), copy the input geometry to the output. If off, the output will only contain the reflection.  
\item {\ttfamily obj.\-Copy\-Input\-Off ()} -\/ If on (the default), copy the input geometry to the output. If off, the output will only contain the reflection.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkregularpolygonsource}{}\section{vtk\-Regular\-Polygon\-Source}\label{vtkgraphics_vtkregularpolygonsource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Regular\-Polygon\-Source is a source object that creates a single n-\/sided polygon and/or polyline. The polygon is centered at a specified point, orthogonal to a specified normal, and with a circumscribing radius set by the user. The user can also specify the number of sides of the polygon ranging from \mbox{[}3,N\mbox{]}.

This object can be used for seeding streamlines or defining regions for clipping/cutting.

To create an instance of class vtk\-Regular\-Polygon\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRegularPolygonSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Regular\-Polygon\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Regular\-Polygon\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instantiation, obtaining type and printing instance values.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instantiation, obtaining type and printing instance values.  
\item {\ttfamily vtk\-Regular\-Polygon\-Source = obj.\-New\-Instance ()} -\/ Standard methods for instantiation, obtaining type and printing instance values.  
\item {\ttfamily vtk\-Regular\-Polygon\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instantiation, obtaining type and printing instance values.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Sides (int )} -\/ Set/\-Get the number of sides of the polygon. By default, the number of sides is set to six.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Sides\-Min\-Value ()} -\/ Set/\-Get the number of sides of the polygon. By default, the number of sides is set to six.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Sides\-Max\-Value ()} -\/ Set/\-Get the number of sides of the polygon. By default, the number of sides is set to six.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Sides ()} -\/ Set/\-Get the number of sides of the polygon. By default, the number of sides is set to six.  
\item {\ttfamily obj.\-Set\-Center (double , double , double )} -\/ Set/\-Get the center of the polygon. By default, the center is set at the origin (0,0,0).  
\item {\ttfamily obj.\-Set\-Center (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the center of the polygon. By default, the center is set at the origin (0,0,0).  
\item {\ttfamily double = obj. Get\-Center ()} -\/ Set/\-Get the center of the polygon. By default, the center is set at the origin (0,0,0).  
\item {\ttfamily obj.\-Set\-Normal (double , double , double )} -\/ Set/\-Get the normal to the polygon. The ordering of the polygon will be counter-\/clockwise around the normal (i.\-e., using the right-\/hand rule). By default, the normal is set to (0,0,1).  
\item {\ttfamily obj.\-Set\-Normal (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the normal to the polygon. The ordering of the polygon will be counter-\/clockwise around the normal (i.\-e., using the right-\/hand rule). By default, the normal is set to (0,0,1).  
\item {\ttfamily double = obj. Get\-Normal ()} -\/ Set/\-Get the normal to the polygon. The ordering of the polygon will be counter-\/clockwise around the normal (i.\-e., using the right-\/hand rule). By default, the normal is set to (0,0,1).  
\item {\ttfamily obj.\-Set\-Radius (double )} -\/ Set/\-Get the radius of the polygon. By default, the radius is set to 0.\-5.  
\item {\ttfamily double = obj.\-Get\-Radius ()} -\/ Set/\-Get the radius of the polygon. By default, the radius is set to 0.\-5.  
\item {\ttfamily obj.\-Set\-Generate\-Polygon (int )} -\/ Control whether a polygon is produced. By default, Generate\-Polygon is enabled.  
\item {\ttfamily int = obj.\-Get\-Generate\-Polygon ()} -\/ Control whether a polygon is produced. By default, Generate\-Polygon is enabled.  
\item {\ttfamily obj.\-Generate\-Polygon\-On ()} -\/ Control whether a polygon is produced. By default, Generate\-Polygon is enabled.  
\item {\ttfamily obj.\-Generate\-Polygon\-Off ()} -\/ Control whether a polygon is produced. By default, Generate\-Polygon is enabled.  
\item {\ttfamily obj.\-Set\-Generate\-Polyline (int )} -\/ Control whether a polyline is produced. By default, Generate\-Polyline is enabled.  
\item {\ttfamily int = obj.\-Get\-Generate\-Polyline ()} -\/ Control whether a polyline is produced. By default, Generate\-Polyline is enabled.  
\item {\ttfamily obj.\-Generate\-Polyline\-On ()} -\/ Control whether a polyline is produced. By default, Generate\-Polyline is enabled.  
\item {\ttfamily obj.\-Generate\-Polyline\-Off ()} -\/ Control whether a polyline is produced. By default, Generate\-Polyline is enabled.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkreversesense}{}\section{vtk\-Reverse\-Sense}\label{vtkgraphics_vtkreversesense}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Reverse\-Sense is a filter that reverses the order of polygonal cells and/or reverses the direction of point and cell normals. Two flags are used to control these operations. Cell reversal means reversing the order of indices in the cell connectivity list. Normal reversal means multiplying the normal vector by -\/1 (both point and cell normals, if present).

To create an instance of class vtk\-Reverse\-Sense, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkReverseSense
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Reverse\-Sense has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Reverse\-Sense class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Reverse\-Sense = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Reverse\-Sense = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Reverse\-Cells (int )} -\/ Flag controls whether to reverse cell ordering.  
\item {\ttfamily int = obj.\-Get\-Reverse\-Cells ()} -\/ Flag controls whether to reverse cell ordering.  
\item {\ttfamily obj.\-Reverse\-Cells\-On ()} -\/ Flag controls whether to reverse cell ordering.  
\item {\ttfamily obj.\-Reverse\-Cells\-Off ()} -\/ Flag controls whether to reverse cell ordering.  
\item {\ttfamily obj.\-Set\-Reverse\-Normals (int )} -\/ Flag controls whether to reverse normal orientation.  
\item {\ttfamily int = obj.\-Get\-Reverse\-Normals ()} -\/ Flag controls whether to reverse normal orientation.  
\item {\ttfamily obj.\-Reverse\-Normals\-On ()} -\/ Flag controls whether to reverse normal orientation.  
\item {\ttfamily obj.\-Reverse\-Normals\-Off ()} -\/ Flag controls whether to reverse normal orientation.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkribbonfilter}{}\section{vtk\-Ribbon\-Filter}\label{vtkgraphics_vtkribbonfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Ribbon\-Filter is a filter to create oriented ribbons from lines defined in polygonal dataset. The orientation of the ribbon is along the line segments and perpendicular to \char`\"{}projected\char`\"{} line normals. Projected line normals are the original line normals projected to be perpendicular to the local line segment. An offset angle can be specified to rotate the ribbon with respect to the normal.

To create an instance of class vtk\-Ribbon\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRibbonFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Ribbon\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Ribbon\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Ribbon\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Ribbon\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Width (double )} -\/ Set the \char`\"{}half\char`\"{} width of the ribbon. If the width is allowed to vary, this is the minimum width. The default is 0.\-5  
\item {\ttfamily double = obj.\-Get\-Width\-Min\-Value ()} -\/ Set the \char`\"{}half\char`\"{} width of the ribbon. If the width is allowed to vary, this is the minimum width. The default is 0.\-5  
\item {\ttfamily double = obj.\-Get\-Width\-Max\-Value ()} -\/ Set the \char`\"{}half\char`\"{} width of the ribbon. If the width is allowed to vary, this is the minimum width. The default is 0.\-5  
\item {\ttfamily double = obj.\-Get\-Width ()} -\/ Set the \char`\"{}half\char`\"{} width of the ribbon. If the width is allowed to vary, this is the minimum width. The default is 0.\-5  
\item {\ttfamily obj.\-Set\-Angle (double )} -\/ Set the offset angle of the ribbon from the line normal. (The angle is expressed in degrees.) The default is 0.\-0  
\item {\ttfamily double = obj.\-Get\-Angle\-Min\-Value ()} -\/ Set the offset angle of the ribbon from the line normal. (The angle is expressed in degrees.) The default is 0.\-0  
\item {\ttfamily double = obj.\-Get\-Angle\-Max\-Value ()} -\/ Set the offset angle of the ribbon from the line normal. (The angle is expressed in degrees.) The default is 0.\-0  
\item {\ttfamily double = obj.\-Get\-Angle ()} -\/ Set the offset angle of the ribbon from the line normal. (The angle is expressed in degrees.) The default is 0.\-0  
\item {\ttfamily obj.\-Set\-Vary\-Width (int )} -\/ Turn on/off the variation of ribbon width with scalar value. The default is Off  
\item {\ttfamily int = obj.\-Get\-Vary\-Width ()} -\/ Turn on/off the variation of ribbon width with scalar value. The default is Off  
\item {\ttfamily obj.\-Vary\-Width\-On ()} -\/ Turn on/off the variation of ribbon width with scalar value. The default is Off  
\item {\ttfamily obj.\-Vary\-Width\-Off ()} -\/ Turn on/off the variation of ribbon width with scalar value. The default is Off  
\item {\ttfamily obj.\-Set\-Width\-Factor (double )} -\/ Set the maximum ribbon width in terms of a multiple of the minimum width. The default is 2.\-0  
\item {\ttfamily double = obj.\-Get\-Width\-Factor ()} -\/ Set the maximum ribbon width in terms of a multiple of the minimum width. The default is 2.\-0  
\item {\ttfamily obj.\-Set\-Default\-Normal (double , double , double )} -\/ Set the default normal to use if no normals are supplied, and Default\-Normal\-On is set. The default is (0,0,1)  
\item {\ttfamily obj.\-Set\-Default\-Normal (double a\mbox{[}3\mbox{]})} -\/ Set the default normal to use if no normals are supplied, and Default\-Normal\-On is set. The default is (0,0,1)  
\item {\ttfamily double = obj. Get\-Default\-Normal ()} -\/ Set the default normal to use if no normals are supplied, and Default\-Normal\-On is set. The default is (0,0,1)  
\item {\ttfamily obj.\-Set\-Use\-Default\-Normal (int )} -\/ Set a boolean to control whether to use default normals. The default is Off  
\item {\ttfamily int = obj.\-Get\-Use\-Default\-Normal ()} -\/ Set a boolean to control whether to use default normals. The default is Off  
\item {\ttfamily obj.\-Use\-Default\-Normal\-On ()} -\/ Set a boolean to control whether to use default normals. The default is Off  
\item {\ttfamily obj.\-Use\-Default\-Normal\-Off ()} -\/ Set a boolean to control whether to use default normals. The default is Off  
\item {\ttfamily obj.\-Set\-Generate\-T\-Coords (int )} -\/ Control whether and how texture coordinates are produced. This is useful for striping the ribbon with time textures, etc.  
\item {\ttfamily int = obj.\-Get\-Generate\-T\-Coords\-Min\-Value ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the ribbon with time textures, etc.  
\item {\ttfamily int = obj.\-Get\-Generate\-T\-Coords\-Max\-Value ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the ribbon with time textures, etc.  
\item {\ttfamily int = obj.\-Get\-Generate\-T\-Coords ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the ribbon with time textures, etc.  
\item {\ttfamily obj.\-Set\-Generate\-T\-Coords\-To\-Off ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the ribbon with time textures, etc.  
\item {\ttfamily obj.\-Set\-Generate\-T\-Coords\-To\-Normalized\-Length ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the ribbon with time textures, etc.  
\item {\ttfamily obj.\-Set\-Generate\-T\-Coords\-To\-Use\-Length ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the ribbon with time textures, etc.  
\item {\ttfamily obj.\-Set\-Generate\-T\-Coords\-To\-Use\-Scalars ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the ribbon with time textures, etc.  
\item {\ttfamily string = obj.\-Get\-Generate\-T\-Coords\-As\-String ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the ribbon with time textures, etc.  
\item {\ttfamily obj.\-Set\-Texture\-Length (double )} -\/ Control the conversion of units during the texture coordinates calculation. The Texture\-Length indicates what length (whether calculated from scalars or length) is mapped to the \mbox{[}0,1) texture space. The default is 1.\-0  
\item {\ttfamily double = obj.\-Get\-Texture\-Length\-Min\-Value ()} -\/ Control the conversion of units during the texture coordinates calculation. The Texture\-Length indicates what length (whether calculated from scalars or length) is mapped to the \mbox{[}0,1) texture space. The default is 1.\-0  
\item {\ttfamily double = obj.\-Get\-Texture\-Length\-Max\-Value ()} -\/ Control the conversion of units during the texture coordinates calculation. The Texture\-Length indicates what length (whether calculated from scalars or length) is mapped to the \mbox{[}0,1) texture space. The default is 1.\-0  
\item {\ttfamily double = obj.\-Get\-Texture\-Length ()} -\/ Control the conversion of units during the texture coordinates calculation. The Texture\-Length indicates what length (whether calculated from scalars or length) is mapped to the \mbox{[}0,1) texture space. The default is 1.\-0  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkrotationalextrusionfilter}{}\section{vtk\-Rotational\-Extrusion\-Filter}\label{vtkgraphics_vtkrotationalextrusionfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Rotational\-Extrusion\-Filter is a modeling filter. It takes polygonal data as input and generates polygonal data on output. The input dataset is swept around the z-\/axis to create new polygonal primitives. These primitives form a \char`\"{}skirt\char`\"{} or swept surface. For example, sweeping a line results in a cylindrical shell, and sweeping a circle creates a torus.

There are a number of control parameters for this filter. You can control whether the sweep of a 2\-D object (i.\-e., polygon or triangle strip) is capped with the generating geometry via the \char`\"{}\-Capping\char`\"{} instance variable. Also, you can control the angle of rotation, and whether translation along the z-\/axis is performed along with the rotation. (Translation is useful for creating \char`\"{}springs\char`\"{}.) You also can adjust the radius of the generating geometry using the \char`\"{}\-Delta\-Rotation\char`\"{} instance variable.

The skirt is generated by locating certain topological features. Free edges (edges of polygons or triangle strips only used by one polygon or triangle strips) generate surfaces. This is true also of lines or polylines. Vertices generate lines.

This filter can be used to model axisymmetric objects like cylinders, bottles, and wine glasses; or translational/rotational symmetric objects like springs or corkscrews.

To create an instance of class vtk\-Rotational\-Extrusion\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRotationalExtrusionFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Rotational\-Extrusion\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Rotational\-Extrusion\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Rotational\-Extrusion\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Rotational\-Extrusion\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Resolution (int )} -\/ Set/\-Get resolution of sweep operation. Resolution controls the number of intermediate node points.  
\item {\ttfamily int = obj.\-Get\-Resolution\-Min\-Value ()} -\/ Set/\-Get resolution of sweep operation. Resolution controls the number of intermediate node points.  
\item {\ttfamily int = obj.\-Get\-Resolution\-Max\-Value ()} -\/ Set/\-Get resolution of sweep operation. Resolution controls the number of intermediate node points.  
\item {\ttfamily int = obj.\-Get\-Resolution ()} -\/ Set/\-Get resolution of sweep operation. Resolution controls the number of intermediate node points.  
\item {\ttfamily obj.\-Set\-Capping (int )} -\/ Turn on/off the capping of the skirt.  
\item {\ttfamily int = obj.\-Get\-Capping ()} -\/ Turn on/off the capping of the skirt.  
\item {\ttfamily obj.\-Capping\-On ()} -\/ Turn on/off the capping of the skirt.  
\item {\ttfamily obj.\-Capping\-Off ()} -\/ Turn on/off the capping of the skirt.  
\item {\ttfamily obj.\-Set\-Angle (double )} -\/ Set/\-Get angle of rotation.  
\item {\ttfamily double = obj.\-Get\-Angle ()} -\/ Set/\-Get angle of rotation.  
\item {\ttfamily obj.\-Set\-Translation (double )} -\/ Set/\-Get total amount of translation along the z-\/axis.  
\item {\ttfamily double = obj.\-Get\-Translation ()} -\/ Set/\-Get total amount of translation along the z-\/axis.  
\item {\ttfamily obj.\-Set\-Delta\-Radius (double )} -\/ Set/\-Get change in radius during sweep process.  
\item {\ttfamily double = obj.\-Get\-Delta\-Radius ()} -\/ Set/\-Get change in radius during sweep process.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkrotationfilter}{}\section{vtk\-Rotation\-Filter}\label{vtkgraphics_vtkrotationfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Rotation\-Filter duplicates a data set by rotation about one of the 3 axis of the dataset's reference. Since it converts data sets into unstructured grids, it is not efficient for structured data sets.

.S\-E\-C\-T\-I\-O\-N Thanks Theophane Foggia of The Swiss National Supercomputing Centre (C\-S\-C\-S) for creating and contributing this filter

To create an instance of class vtk\-Rotation\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRotationFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Rotation\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Rotation\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Rotation\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Rotation\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Axis (int )} -\/ Set the axis of rotation to use. It is set by default to Z.  
\item {\ttfamily int = obj.\-Get\-Axis\-Min\-Value ()} -\/ Set the axis of rotation to use. It is set by default to Z.  
\item {\ttfamily int = obj.\-Get\-Axis\-Max\-Value ()} -\/ Set the axis of rotation to use. It is set by default to Z.  
\item {\ttfamily int = obj.\-Get\-Axis ()} -\/ Set the axis of rotation to use. It is set by default to Z.  
\item {\ttfamily obj.\-Set\-Axis\-To\-X ()} -\/ Set the axis of rotation to use. It is set by default to Z.  
\item {\ttfamily obj.\-Set\-Axis\-To\-Y ()} -\/ Set the axis of rotation to use. It is set by default to Z.  
\item {\ttfamily obj.\-Set\-Axis\-To\-Z ()} -\/ Set the axis of rotation to use. It is set by default to Z.  
\item {\ttfamily obj.\-Set\-Angle (double )} -\/ Set the rotation angle to use.  
\item {\ttfamily double = obj.\-Get\-Angle ()} -\/ Set the rotation angle to use.  
\item {\ttfamily obj.\-Set\-Center (double , double , double )} -\/ Set the rotation center coordinates.  
\item {\ttfamily obj.\-Set\-Center (double a\mbox{[}3\mbox{]})} -\/ Set the rotation center coordinates.  
\item {\ttfamily double = obj. Get\-Center ()} -\/ Set the rotation center coordinates.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Copies (int )} -\/ Set the number of copies to create. The source will be rotated N times and a new polydata copy of the original created at each angular position All copies will be appended to form a single output  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Copies ()} -\/ Set the number of copies to create. The source will be rotated N times and a new polydata copy of the original created at each angular position All copies will be appended to form a single output  
\item {\ttfamily obj.\-Set\-Copy\-Input (int )} -\/ If on (the default), copy the input geometry to the output. If off, the output will only contain the rotation.  
\item {\ttfamily int = obj.\-Get\-Copy\-Input ()} -\/ If on (the default), copy the input geometry to the output. If off, the output will only contain the rotation.  
\item {\ttfamily obj.\-Copy\-Input\-On ()} -\/ If on (the default), copy the input geometry to the output. If off, the output will only contain the rotation.  
\item {\ttfamily obj.\-Copy\-Input\-Off ()} -\/ If on (the default), copy the input geometry to the output. If off, the output will only contain the rotation.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkruledsurfacefilter}{}\section{vtk\-Ruled\-Surface\-Filter}\label{vtkgraphics_vtkruledsurfacefilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Ruled\-Surface\-Filter is a filter that generates a surface from a set of lines. The lines are assumed to be \char`\"{}parallel\char`\"{} in the sense that they do not intersect and remain somewhat close to one another. A surface is generated by connecting the points defining each pair of lines with straight lines. This creates a strip for each pair of lines (i.\-e., a triangulation is created from two generating lines). The filter can handle an arbitrary number of lines, with lines i and i+1 assumed connected. Note that there are several different approaches for creating the ruled surface, the method for creating the surface can either use the input points or resample from the polylines (using a user-\/specified resolution).

This filter offers some other important features. A Distance\-Factor ivar is used to decide when two lines are too far apart to connect. (The factor is a multiple of the distance between the first two points of the two lines defining the strip.) If the distance between the two generating lines becomes too great, then the surface is not generated in that region. (Note\-: if the lines separate and then merge, then a hole can be generated in the surface.) In addition, the Offset and On\-Ration ivars can be used to create nifty striped surfaces. Closed surfaces (e.\-g., tubes) can be created by setting the Close\-Surface ivar. (The surface can be closed in the other direction by repeating the first and last point in the polylines defining the surface.)

An important use of this filter is to combine it with vtk\-Stream\-Line to generate stream surfaces. It can also be used to create surfaces from contours.

To create an instance of class vtk\-Ruled\-Surface\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRuledSurfaceFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Ruled\-Surface\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Ruled\-Surface\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Ruled\-Surface\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Ruled\-Surface\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Distance\-Factor (double )} -\/ Set/\-Get the factor that controls tearing of the surface.  
\item {\ttfamily double = obj.\-Get\-Distance\-Factor\-Min\-Value ()} -\/ Set/\-Get the factor that controls tearing of the surface.  
\item {\ttfamily double = obj.\-Get\-Distance\-Factor\-Max\-Value ()} -\/ Set/\-Get the factor that controls tearing of the surface.  
\item {\ttfamily double = obj.\-Get\-Distance\-Factor ()} -\/ Set/\-Get the factor that controls tearing of the surface.  
\item {\ttfamily obj.\-Set\-On\-Ratio (int )} -\/ Control the striping of the ruled surface. If On\-Ratio is greater than 1, then every nth strip is turned on, beginning with the Offset strip.  
\item {\ttfamily int = obj.\-Get\-On\-Ratio\-Min\-Value ()} -\/ Control the striping of the ruled surface. If On\-Ratio is greater than 1, then every nth strip is turned on, beginning with the Offset strip.  
\item {\ttfamily int = obj.\-Get\-On\-Ratio\-Max\-Value ()} -\/ Control the striping of the ruled surface. If On\-Ratio is greater than 1, then every nth strip is turned on, beginning with the Offset strip.  
\item {\ttfamily int = obj.\-Get\-On\-Ratio ()} -\/ Control the striping of the ruled surface. If On\-Ratio is greater than 1, then every nth strip is turned on, beginning with the Offset strip.  
\item {\ttfamily obj.\-Set\-Offset (int )} -\/ Control the striping of the ruled surface. The offset sets the first stripe that is visible. Offset is generally used with On\-Ratio to create nifty striping effects.  
\item {\ttfamily int = obj.\-Get\-Offset\-Min\-Value ()} -\/ Control the striping of the ruled surface. The offset sets the first stripe that is visible. Offset is generally used with On\-Ratio to create nifty striping effects.  
\item {\ttfamily int = obj.\-Get\-Offset\-Max\-Value ()} -\/ Control the striping of the ruled surface. The offset sets the first stripe that is visible. Offset is generally used with On\-Ratio to create nifty striping effects.  
\item {\ttfamily int = obj.\-Get\-Offset ()} -\/ Control the striping of the ruled surface. The offset sets the first stripe that is visible. Offset is generally used with On\-Ratio to create nifty striping effects.  
\item {\ttfamily obj.\-Set\-Close\-Surface (int )} -\/ Indicate whether the surface is to be closed. If this boolean is on, then the first and last polyline are used to generate a stripe that closes the surface. (Note\-: to close the surface in the other direction, repeat the first point in the polyline as the last point in the polyline.)  
\item {\ttfamily int = obj.\-Get\-Close\-Surface ()} -\/ Indicate whether the surface is to be closed. If this boolean is on, then the first and last polyline are used to generate a stripe that closes the surface. (Note\-: to close the surface in the other direction, repeat the first point in the polyline as the last point in the polyline.)  
\item {\ttfamily obj.\-Close\-Surface\-On ()} -\/ Indicate whether the surface is to be closed. If this boolean is on, then the first and last polyline are used to generate a stripe that closes the surface. (Note\-: to close the surface in the other direction, repeat the first point in the polyline as the last point in the polyline.)  
\item {\ttfamily obj.\-Close\-Surface\-Off ()} -\/ Indicate whether the surface is to be closed. If this boolean is on, then the first and last polyline are used to generate a stripe that closes the surface. (Note\-: to close the surface in the other direction, repeat the first point in the polyline as the last point in the polyline.)  
\item {\ttfamily obj.\-Set\-Ruled\-Mode (int )} -\/ Set the mode by which to create the ruled surface. (Dramatically different results are possible depending on the chosen mode.) The resample mode evenly resamples the polylines (based on length) and generates triangle strips. The point walk mode uses the existing points and walks around the polyline using existing points.  
\item {\ttfamily int = obj.\-Get\-Ruled\-Mode\-Min\-Value ()} -\/ Set the mode by which to create the ruled surface. (Dramatically different results are possible depending on the chosen mode.) The resample mode evenly resamples the polylines (based on length) and generates triangle strips. The point walk mode uses the existing points and walks around the polyline using existing points.  
\item {\ttfamily int = obj.\-Get\-Ruled\-Mode\-Max\-Value ()} -\/ Set the mode by which to create the ruled surface. (Dramatically different results are possible depending on the chosen mode.) The resample mode evenly resamples the polylines (based on length) and generates triangle strips. The point walk mode uses the existing points and walks around the polyline using existing points.  
\item {\ttfamily int = obj.\-Get\-Ruled\-Mode ()} -\/ Set the mode by which to create the ruled surface. (Dramatically different results are possible depending on the chosen mode.) The resample mode evenly resamples the polylines (based on length) and generates triangle strips. The point walk mode uses the existing points and walks around the polyline using existing points.  
\item {\ttfamily obj.\-Set\-Ruled\-Mode\-To\-Resample ()} -\/ Set the mode by which to create the ruled surface. (Dramatically different results are possible depending on the chosen mode.) The resample mode evenly resamples the polylines (based on length) and generates triangle strips. The point walk mode uses the existing points and walks around the polyline using existing points.  
\item {\ttfamily obj.\-Set\-Ruled\-Mode\-To\-Point\-Walk ()} -\/ Set the mode by which to create the ruled surface. (Dramatically different results are possible depending on the chosen mode.) The resample mode evenly resamples the polylines (based on length) and generates triangle strips. The point walk mode uses the existing points and walks around the polyline using existing points.  
\item {\ttfamily string = obj.\-Get\-Ruled\-Mode\-As\-String ()} -\/ Set the mode by which to create the ruled surface. (Dramatically different results are possible depending on the chosen mode.) The resample mode evenly resamples the polylines (based on length) and generates triangle strips. The point walk mode uses the existing points and walks around the polyline using existing points.  
\item {\ttfamily obj.\-Set\-Resolution (int , int )} -\/ If the ruled surface generation mode is R\-E\-S\-A\-M\-P\-L\-E, then these parameters are used to determine the resample rate. Resolution\mbox{[}0\mbox{]} defines the resolution in the direction of the polylines; Resolution\mbox{[}1\mbox{]} defines the resolution across the polylines (i.\-e., direction orthogonal to Resolution\mbox{[}0\mbox{]}).  
\item {\ttfamily obj.\-Set\-Resolution (int a\mbox{[}2\mbox{]})} -\/ If the ruled surface generation mode is R\-E\-S\-A\-M\-P\-L\-E, then these parameters are used to determine the resample rate. Resolution\mbox{[}0\mbox{]} defines the resolution in the direction of the polylines; Resolution\mbox{[}1\mbox{]} defines the resolution across the polylines (i.\-e., direction orthogonal to Resolution\mbox{[}0\mbox{]}).  
\item {\ttfamily int = obj. Get\-Resolution ()} -\/ If the ruled surface generation mode is R\-E\-S\-A\-M\-P\-L\-E, then these parameters are used to determine the resample rate. Resolution\mbox{[}0\mbox{]} defines the resolution in the direction of the polylines; Resolution\mbox{[}1\mbox{]} defines the resolution across the polylines (i.\-e., direction orthogonal to Resolution\mbox{[}0\mbox{]}).  
\item {\ttfamily obj.\-Set\-Pass\-Lines (int )} -\/ Indicate whether the generating lines are to be passed to the output. By defualt lines are not passed to the output.  
\item {\ttfamily int = obj.\-Get\-Pass\-Lines ()} -\/ Indicate whether the generating lines are to be passed to the output. By defualt lines are not passed to the output.  
\item {\ttfamily obj.\-Pass\-Lines\-On ()} -\/ Indicate whether the generating lines are to be passed to the output. By defualt lines are not passed to the output.  
\item {\ttfamily obj.\-Pass\-Lines\-Off ()} -\/ Indicate whether the generating lines are to be passed to the output. By defualt lines are not passed to the output.  
\item {\ttfamily obj.\-Set\-Orient\-Loops (int )} -\/ Indicate whether the starting points of the loops need to be determined. If set to 0, then its assumes that the 0th point of each loop should be always connected By defualt the loops are not oriented.  
\item {\ttfamily int = obj.\-Get\-Orient\-Loops ()} -\/ Indicate whether the starting points of the loops need to be determined. If set to 0, then its assumes that the 0th point of each loop should be always connected By defualt the loops are not oriented.  
\item {\ttfamily obj.\-Orient\-Loops\-On ()} -\/ Indicate whether the starting points of the loops need to be determined. If set to 0, then its assumes that the 0th point of each loop should be always connected By defualt the loops are not oriented.  
\item {\ttfamily obj.\-Orient\-Loops\-Off ()} -\/ Indicate whether the starting points of the loops need to be determined. If set to 0, then its assumes that the 0th point of each loop should be always connected By defualt the loops are not oriented.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtksectorsource}{}\section{vtk\-Sector\-Source}\label{vtkgraphics_vtksectorsource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Sector\-Source creates a sector of a polygonal disk. The disk has zero height. The user can specify the inner and outer radius of the disk, the z-\/coordinate, and the radial and circumferential resolution of the polygonal representation.

To create an instance of class vtk\-Sector\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSectorSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Sector\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Sector\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Sector\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Sector\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Inner\-Radius (double )} -\/ Specify inner radius of the sector.  
\item {\ttfamily double = obj.\-Get\-Inner\-Radius\-Min\-Value ()} -\/ Specify inner radius of the sector.  
\item {\ttfamily double = obj.\-Get\-Inner\-Radius\-Max\-Value ()} -\/ Specify inner radius of the sector.  
\item {\ttfamily double = obj.\-Get\-Inner\-Radius ()} -\/ Specify inner radius of the sector.  
\item {\ttfamily obj.\-Set\-Outer\-Radius (double )} -\/ Specify outer radius of the sector.  
\item {\ttfamily double = obj.\-Get\-Outer\-Radius\-Min\-Value ()} -\/ Specify outer radius of the sector.  
\item {\ttfamily double = obj.\-Get\-Outer\-Radius\-Max\-Value ()} -\/ Specify outer radius of the sector.  
\item {\ttfamily double = obj.\-Get\-Outer\-Radius ()} -\/ Specify outer radius of the sector.  
\item {\ttfamily obj.\-Set\-Z\-Coord (double )} -\/ Specify the z coordinate of the sector.  
\item {\ttfamily double = obj.\-Get\-Z\-Coord\-Min\-Value ()} -\/ Specify the z coordinate of the sector.  
\item {\ttfamily double = obj.\-Get\-Z\-Coord\-Max\-Value ()} -\/ Specify the z coordinate of the sector.  
\item {\ttfamily double = obj.\-Get\-Z\-Coord ()} -\/ Specify the z coordinate of the sector.  
\item {\ttfamily obj.\-Set\-Radial\-Resolution (int )} -\/ Set the number of points in radius direction.  
\item {\ttfamily int = obj.\-Get\-Radial\-Resolution\-Min\-Value ()} -\/ Set the number of points in radius direction.  
\item {\ttfamily int = obj.\-Get\-Radial\-Resolution\-Max\-Value ()} -\/ Set the number of points in radius direction.  
\item {\ttfamily int = obj.\-Get\-Radial\-Resolution ()} -\/ Set the number of points in radius direction.  
\item {\ttfamily obj.\-Set\-Circumferential\-Resolution (int )} -\/ Set the number of points in circumferential direction.  
\item {\ttfamily int = obj.\-Get\-Circumferential\-Resolution\-Min\-Value ()} -\/ Set the number of points in circumferential direction.  
\item {\ttfamily int = obj.\-Get\-Circumferential\-Resolution\-Max\-Value ()} -\/ Set the number of points in circumferential direction.  
\item {\ttfamily int = obj.\-Get\-Circumferential\-Resolution ()} -\/ Set the number of points in circumferential direction.  
\item {\ttfamily obj.\-Set\-Start\-Angle (double )} -\/ Set the start angle of the sector.  
\item {\ttfamily double = obj.\-Get\-Start\-Angle\-Min\-Value ()} -\/ Set the start angle of the sector.  
\item {\ttfamily double = obj.\-Get\-Start\-Angle\-Max\-Value ()} -\/ Set the start angle of the sector.  
\item {\ttfamily double = obj.\-Get\-Start\-Angle ()} -\/ Set the start angle of the sector.  
\item {\ttfamily obj.\-Set\-End\-Angle (double )} -\/ Set the end angle of the sector.  
\item {\ttfamily double = obj.\-Get\-End\-Angle\-Min\-Value ()} -\/ Set the end angle of the sector.  
\item {\ttfamily double = obj.\-Get\-End\-Angle\-Max\-Value ()} -\/ Set the end angle of the sector.  
\item {\ttfamily double = obj.\-Get\-End\-Angle ()} -\/ Set the end angle of the sector.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkselectenclosedpoints}{}\section{vtk\-Select\-Enclosed\-Points}\label{vtkgraphics_vtkselectenclosedpoints}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Select\-Enclosed\-Points is a filter that evaluates all the input points to determine whether they are in an enclosed surface. The filter produces a (0,1) mask (in the form of a vtk\-Data\-Array) that indicates whether points are outside (mask value=0) or inside (mask value=1) a provided surface. (The name of the output vtk\-Data\-Array is \char`\"{}\-Selected\-Points\-Array\char`\"{}.)

After running the filter, it is possible to query it as to whether a point is inside/outside by invoking the Is\-Inside(pt\-Id) method.

To create an instance of class vtk\-Select\-Enclosed\-Points, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSelectEnclosedPoints
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Select\-Enclosed\-Points has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Select\-Enclosed\-Points class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Select\-Enclosed\-Points = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Select\-Enclosed\-Points = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Surface (vtk\-Poly\-Data pd)} -\/ Set the surface to be used to test for containment. Two methods are provided\-: one directly for vtk\-Poly\-Data, and one for the output of a filter.  
\item {\ttfamily obj.\-Set\-Surface\-Connection (vtk\-Algorithm\-Output alg\-Output)} -\/ Set the surface to be used to test for containment. Two methods are provided\-: one directly for vtk\-Poly\-Data, and one for the output of a filter.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Surface ()} -\/ Return a pointer to the enclosing surface.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Surface (vtk\-Information\-Vector source\-Info)} -\/ Return a pointer to the enclosing surface.  
\item {\ttfamily obj.\-Set\-Inside\-Out (int )} -\/ By default, points inside the surface are marked inside or sent to the output. If Inside\-Out is on, then the points outside the surface are marked inside.  
\item {\ttfamily obj.\-Inside\-Out\-On ()} -\/ By default, points inside the surface are marked inside or sent to the output. If Inside\-Out is on, then the points outside the surface are marked inside.  
\item {\ttfamily obj.\-Inside\-Out\-Off ()} -\/ By default, points inside the surface are marked inside or sent to the output. If Inside\-Out is on, then the points outside the surface are marked inside.  
\item {\ttfamily int = obj.\-Get\-Inside\-Out ()} -\/ By default, points inside the surface are marked inside or sent to the output. If Inside\-Out is on, then the points outside the surface are marked inside.  
\item {\ttfamily obj.\-Set\-Check\-Surface (int )} -\/ Specify whether to check the surface for closure. If on, then the algorithm first checks to see if the surface is closed and manifold.  
\item {\ttfamily obj.\-Check\-Surface\-On ()} -\/ Specify whether to check the surface for closure. If on, then the algorithm first checks to see if the surface is closed and manifold.  
\item {\ttfamily obj.\-Check\-Surface\-Off ()} -\/ Specify whether to check the surface for closure. If on, then the algorithm first checks to see if the surface is closed and manifold.  
\item {\ttfamily int = obj.\-Get\-Check\-Surface ()} -\/ Specify whether to check the surface for closure. If on, then the algorithm first checks to see if the surface is closed and manifold.  
\item {\ttfamily int = obj.\-Is\-Inside (vtk\-Id\-Type input\-Pt\-Id)} -\/ Query an input point id as to whether it is inside or outside. Note that the result requires that the filter execute first.  
\item {\ttfamily obj.\-Set\-Tolerance (double )} -\/ Specify the tolerance on the intersection. The tolerance is expressed as a fraction of the bounding box of the enclosing surface.  
\item {\ttfamily double = obj.\-Get\-Tolerance\-Min\-Value ()} -\/ Specify the tolerance on the intersection. The tolerance is expressed as a fraction of the bounding box of the enclosing surface.  
\item {\ttfamily double = obj.\-Get\-Tolerance\-Max\-Value ()} -\/ Specify the tolerance on the intersection. The tolerance is expressed as a fraction of the bounding box of the enclosing surface.  
\item {\ttfamily double = obj.\-Get\-Tolerance ()} -\/ Specify the tolerance on the intersection. The tolerance is expressed as a fraction of the bounding box of the enclosing surface.  
\item {\ttfamily obj.\-Initialize (vtk\-Poly\-Data surface)} -\/ This is a backdoor that can be used to test many points for containment. First initialize the instance, then repeated calls to Is\-Inside\-Surface() can be used without rebuilding the search structures. The complete method releases memory.  
\item {\ttfamily int = obj.\-Is\-Inside\-Surface (double x, double y, double z)} -\/ This is a backdoor that can be used to test many points for containment. First initialize the instance, then repeated calls to Is\-Inside\-Surface() can be used without rebuilding the search structures. The complete method releases memory.  
\item {\ttfamily int = obj.\-Is\-Inside\-Surface (double x\mbox{[}3\mbox{]})} -\/ This is a backdoor that can be used to test many points for containment. First initialize the instance, then repeated calls to Is\-Inside\-Surface() can be used without rebuilding the search structures. The complete method releases memory.  
\item {\ttfamily obj.\-Complete ()} -\/ This is a backdoor that can be used to test many points for containment. First initialize the instance, then repeated calls to Is\-Inside\-Surface() can be used without rebuilding the search structures. The complete method releases memory.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkselectpolydata}{}\section{vtk\-Select\-Poly\-Data}\label{vtkgraphics_vtkselectpolydata}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Select\-Poly\-Data is a filter that selects polygonal data based on defining a \char`\"{}loop\char`\"{} and indicating the region inside of the loop. The mesh within the loop consists of complete cells (the cells are not cut). Alternatively, this filter can be used to generate scalars. These scalar values, which are a distance measure to the loop, can be used to clip, contour. or extract data (i.\-e., anything that an implicit function can do).

The loop is defined by an array of x-\/y-\/z point coordinates. (Coordinates should be in the same coordinate space as the input polygonal data.) The loop can be concave and non-\/planar, but not self-\/intersecting. The input to the filter is a polygonal mesh (only surface primitives such as triangle strips and polygons); the output is either a) a portion of the original mesh laying within the selection loop (Generate\-Selection\-Scalars\-Off); or b) the same polygonal mesh with the addition of scalar values (Generate\-Selection\-Scalars\-On).

The algorithm works as follows. For each point coordinate in the loop, the closest point in the mesh is found. The result is a loop of closest point ids from the mesh. Then, the edges in the mesh connecting the closest points (and laying along the lines forming the loop) are found. A greedy edge tracking procedure is used as follows. At the current point, the mesh edge oriented in the direction of and whose end point is closest to the line is chosen. The edge is followed to the new end point, and the procedure is repeated. This process continues until the entire loop has been created.

To determine what portion of the mesh is inside and outside of the loop, three options are possible. 1) the smallest connected region, 2) the largest connected region, and 3) the connected region closest to a user specified point. (Set the ivar Selection\-Mode.)

Once the loop is computed as above, the Generate\-Selection\-Scalars controls the output of the filter. If on, then scalar values are generated based on distance to the loop lines. Otherwise, the cells laying inside the selection loop are output. By default, the mesh lying within the loop is output; however, if Inside\-Out is on, then the portion of the mesh lying outside of the loop is output.

The filter can be configured to generate the unselected portions of the mesh as output by setting Generate\-Unselected\-Output. Use the method Get\-Unselected\-Output to access this output. (Note\-: this flag is pertinent only when Generate\-Selection\-Scalars is off.)

To create an instance of class vtk\-Select\-Poly\-Data, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSelectPolyData
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Select\-Poly\-Data has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Select\-Poly\-Data class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Select\-Poly\-Data = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Select\-Poly\-Data = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Generate\-Selection\-Scalars (int )} -\/ Set/\-Get the flag to control behavior of the filter. If Generate\-Selection\-Scalars is on, then the output of the filter is the same as the input, except that scalars are generated. If off, the filter outputs the cells laying inside the loop, and does not generate scalars.  
\item {\ttfamily int = obj.\-Get\-Generate\-Selection\-Scalars ()} -\/ Set/\-Get the flag to control behavior of the filter. If Generate\-Selection\-Scalars is on, then the output of the filter is the same as the input, except that scalars are generated. If off, the filter outputs the cells laying inside the loop, and does not generate scalars.  
\item {\ttfamily obj.\-Generate\-Selection\-Scalars\-On ()} -\/ Set/\-Get the flag to control behavior of the filter. If Generate\-Selection\-Scalars is on, then the output of the filter is the same as the input, except that scalars are generated. If off, the filter outputs the cells laying inside the loop, and does not generate scalars.  
\item {\ttfamily obj.\-Generate\-Selection\-Scalars\-Off ()} -\/ Set/\-Get the flag to control behavior of the filter. If Generate\-Selection\-Scalars is on, then the output of the filter is the same as the input, except that scalars are generated. If off, the filter outputs the cells laying inside the loop, and does not generate scalars.  
\item {\ttfamily obj.\-Set\-Inside\-Out (int )} -\/ Set/\-Get the Inside\-Out flag. When off, the mesh within the loop is extracted. When on, the mesh outside the loop is extracted.  
\item {\ttfamily int = obj.\-Get\-Inside\-Out ()} -\/ Set/\-Get the Inside\-Out flag. When off, the mesh within the loop is extracted. When on, the mesh outside the loop is extracted.  
\item {\ttfamily obj.\-Inside\-Out\-On ()} -\/ Set/\-Get the Inside\-Out flag. When off, the mesh within the loop is extracted. When on, the mesh outside the loop is extracted.  
\item {\ttfamily obj.\-Inside\-Out\-Off ()} -\/ Set/\-Get the Inside\-Out flag. When off, the mesh within the loop is extracted. When on, the mesh outside the loop is extracted.  
\item {\ttfamily obj.\-Set\-Loop (vtk\-Points )} -\/ Set/\-Get the array of point coordinates defining the loop. There must be at least three points used to define a loop.  
\item {\ttfamily vtk\-Points = obj.\-Get\-Loop ()} -\/ Set/\-Get the array of point coordinates defining the loop. There must be at least three points used to define a loop.  
\item {\ttfamily obj.\-Set\-Selection\-Mode (int )} -\/ Control how inside/outside of loop is defined.  
\item {\ttfamily int = obj.\-Get\-Selection\-Mode\-Min\-Value ()} -\/ Control how inside/outside of loop is defined.  
\item {\ttfamily int = obj.\-Get\-Selection\-Mode\-Max\-Value ()} -\/ Control how inside/outside of loop is defined.  
\item {\ttfamily int = obj.\-Get\-Selection\-Mode ()} -\/ Control how inside/outside of loop is defined.  
\item {\ttfamily obj.\-Set\-Selection\-Mode\-To\-Smallest\-Region ()} -\/ Control how inside/outside of loop is defined.  
\item {\ttfamily obj.\-Set\-Selection\-Mode\-To\-Largest\-Region ()} -\/ Control how inside/outside of loop is defined.  
\item {\ttfamily obj.\-Set\-Selection\-Mode\-To\-Closest\-Point\-Region ()} -\/ Control how inside/outside of loop is defined.  
\item {\ttfamily string = obj.\-Get\-Selection\-Mode\-As\-String ()} -\/ Control how inside/outside of loop is defined.  
\item {\ttfamily obj.\-Set\-Generate\-Unselected\-Output (int )} -\/ Control whether a second output is generated. The second output contains the polygonal data that's not been selected.  
\item {\ttfamily int = obj.\-Get\-Generate\-Unselected\-Output ()} -\/ Control whether a second output is generated. The second output contains the polygonal data that's not been selected.  
\item {\ttfamily obj.\-Generate\-Unselected\-Output\-On ()} -\/ Control whether a second output is generated. The second output contains the polygonal data that's not been selected.  
\item {\ttfamily obj.\-Generate\-Unselected\-Output\-Off ()} -\/ Control whether a second output is generated. The second output contains the polygonal data that's not been selected.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Unselected\-Output ()} -\/ Return output that hasn't been selected (if Genreate\-Unselected\-Output is enabled).  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Selection\-Edges ()} -\/ Return the (mesh) edges of the selection region.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkshrinkfilter}{}\section{vtk\-Shrink\-Filter}\label{vtkgraphics_vtkshrinkfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Shrink\-Filter shrinks cells composing an arbitrary data set towards their centroid. The centroid of a cell is computed as the average position of the cell points. Shrinking results in disconnecting the cells from one another. The output of this filter is of general dataset type vtk\-Unstructured\-Grid.

To create an instance of class vtk\-Shrink\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkShrinkFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Shrink\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Shrink\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Shrink\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Shrink\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Shrink\-Factor (double )} -\/ Get/\-Set the fraction of shrink for each cell. The default is 0.\-5.  
\item {\ttfamily double = obj.\-Get\-Shrink\-Factor\-Min\-Value ()} -\/ Get/\-Set the fraction of shrink for each cell. The default is 0.\-5.  
\item {\ttfamily double = obj.\-Get\-Shrink\-Factor\-Max\-Value ()} -\/ Get/\-Set the fraction of shrink for each cell. The default is 0.\-5.  
\item {\ttfamily double = obj.\-Get\-Shrink\-Factor ()} -\/ Get/\-Set the fraction of shrink for each cell. The default is 0.\-5.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkshrinkpolydata}{}\section{vtk\-Shrink\-Poly\-Data}\label{vtkgraphics_vtkshrinkpolydata}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Shrink\-Poly\-Data shrinks cells composing a polygonal dataset (e.\-g., vertices, lines, polygons, and triangle strips) towards their centroid. The centroid of a cell is computed as the average position of the cell points. Shrinking results in disconnecting the cells from one another. The output dataset type of this filter is polygonal data.

During execution the filter passes its input cell data to its output. Point data attributes are copied to the points created during the shrinking process.

To create an instance of class vtk\-Shrink\-Poly\-Data, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkShrinkPolyData
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Shrink\-Poly\-Data has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Shrink\-Poly\-Data class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Shrink\-Poly\-Data = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Shrink\-Poly\-Data = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Shrink\-Factor (double )} -\/ Set the fraction of shrink for each cell.  
\item {\ttfamily double = obj.\-Get\-Shrink\-Factor\-Min\-Value ()} -\/ Set the fraction of shrink for each cell.  
\item {\ttfamily double = obj.\-Get\-Shrink\-Factor\-Max\-Value ()} -\/ Set the fraction of shrink for each cell.  
\item {\ttfamily double = obj.\-Get\-Shrink\-Factor ()} -\/ Get the fraction of shrink for each cell.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtksimpleelevationfilter}{}\section{vtk\-Simple\-Elevation\-Filter}\label{vtkgraphics_vtksimpleelevationfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Simple\-Elevation\-Filter is a filter to generate scalar values from a dataset. The scalar values are generated by dotting a user-\/specified vector against a vector defined from the input dataset points to the origin.

To create an instance of class vtk\-Simple\-Elevation\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSimpleElevationFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Simple\-Elevation\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Elevation\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Simple\-Elevation\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Simple\-Elevation\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Vector (double , double , double )} -\/ Define one end of the line (small scalar values).  
\item {\ttfamily obj.\-Set\-Vector (double a\mbox{[}3\mbox{]})} -\/ Define one end of the line (small scalar values).  
\item {\ttfamily double = obj. Get\-Vector ()} -\/ Define one end of the line (small scalar values).  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkslicecubes}{}\section{vtk\-Slice\-Cubes}\label{vtkgraphics_vtkslicecubes}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Slice\-Cubes is a special version of the marching cubes filter. Instead of ingesting an entire volume at once it processes only four slices at a time. This way, it can generate isosurfaces from huge volumes. Also, the output of this object is written to a marching cubes triangle file. That way, output triangles do not need to be held in memory.

To use vtk\-Slice\-Cubes you must specify an instance of vtk\-Volume\-Reader to read the data. Set this object up with the proper file prefix, image range, data origin, data dimensions, header size, data mask, and swap bytes flag. The vtk\-Slice\-Cubes object will then take over and read slices as necessary. You also will need to specify the name of an output marching cubes triangle file.

To create an instance of class vtk\-Slice\-Cubes, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSliceCubes
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Slice\-Cubes has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Slice\-Cubes class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Slice\-Cubes = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Slice\-Cubes = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Write ()}  
\item {\ttfamily obj.\-Update ()}  
\item {\ttfamily obj.\-Set\-Reader (vtk\-Volume\-Reader )} -\/ Set/get object to read slices.  
\item {\ttfamily vtk\-Volume\-Reader = obj.\-Get\-Reader ()} -\/ Set/get object to read slices.  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify file name of marching cubes output file.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify file name of marching cubes output file.  
\item {\ttfamily obj.\-Set\-Value (double )} -\/ Set/get isosurface contour value.  
\item {\ttfamily double = obj.\-Get\-Value ()} -\/ Set/get isosurface contour value.  
\item {\ttfamily obj.\-Set\-Limits\-File\-Name (string )} -\/ Specify file name of marching cubes limits file. The limits file speeds up subsequent reading of output triangle file.  
\item {\ttfamily string = obj.\-Get\-Limits\-File\-Name ()} -\/ Specify file name of marching cubes limits file. The limits file speeds up subsequent reading of output triangle file.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtksmoothpolydatafilter}{}\section{vtk\-Smooth\-Poly\-Data\-Filter}\label{vtkgraphics_vtksmoothpolydatafilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Smooth\-Poly\-Data\-Filter is a filter that adjusts point coordinates using Laplacian smoothing. The effect is to \char`\"{}relax\char`\"{} the mesh, making the cells better shaped and the vertices more evenly distributed. Note that this filter operates on the lines, polygons, and triangle strips composing an instance of vtk\-Poly\-Data. Vertex or poly-\/vertex cells are never modified.

The algorithm proceeds as follows. For each vertex v, a topological and geometric analysis is performed to determine which vertices are connected to v, and which cells are connected to v. Then, a connectivity array is constructed for each vertex. (The connectivity array is a list of lists of vertices that directly attach to each vertex.) Next, an iteration phase begins over all vertices. For each vertex v, the coordinates of v are modified according to an average of the connected vertices. (A relaxation factor is available to control the amount of displacement of v). The process repeats for each vertex. This pass over the list of vertices is a single iteration. Many iterations (generally around 20 or so) are repeated until the desired result is obtained.

There are some special instance variables used to control the execution of this filter. (These ivars basically control what vertices can be smoothed, and the creation of the connectivity array.) The Boundary\-Smoothing ivar enables/disables the smoothing operation on vertices that are on the \char`\"{}boundary\char`\"{} of the mesh. A boundary vertex is one that is surrounded by a semi-\/cycle of polygons (or used by a single line).

Another important ivar is Feature\-Edge\-Smoothing. If this ivar is enabled, then interior vertices are classified as either \char`\"{}simple\char`\"{}, \char`\"{}interior edge\char`\"{}, or \char`\"{}fixed\char`\"{}, and smoothed differently. (Interior vertices are manifold vertices surrounded by a cycle of polygons; or used by two line cells.) The classification is based on the number of feature edges attached to v. A feature edge occurs when the angle between the two surface normals of a polygon sharing an edge is greater than the Feature\-Angle ivar. Then, vertices used by no feature edges are classified \char`\"{}simple\char`\"{}, vertices used by exactly two feature edges are classified \char`\"{}interior edge\char`\"{}, and all others are \char`\"{}fixed\char`\"{} vertices.

Once the classification is known, the vertices are smoothed differently. Corner (i.\-e., fixed) vertices are not smoothed at all. Simple vertices are smoothed as before (i.\-e., average of connected vertex coordinates). Interior edge vertices are smoothed only along their two connected edges, and only if the angle between the edges is less than the Edge\-Angle ivar.

The total smoothing can be controlled by using two ivars. The Number\-Of\-Iterations is a cap on the maximum number of smoothing passes. The Convergence ivar is a limit on the maximum point motion. If the maximum motion during an iteration is less than Convergence, then the smoothing process terminates. (Convergence is expressed as a fraction of the diagonal of the bounding box.)

There are two instance variables that control the generation of error data. If the ivar Generate\-Error\-Scalars is on, then a scalar value indicating the distance of each vertex from its original position is computed. If the ivar Generate\-Error\-Vectors is on, then a vector representing change in position is computed.

Optionally you can further control the smoothing process by defining a second input\-: the Source. If defined, the input mesh is constrained to lie on the surface defined by the Source ivar.

To create an instance of class vtk\-Smooth\-Poly\-Data\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSmoothPolyDataFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Smooth\-Poly\-Data\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Smooth\-Poly\-Data\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Smooth\-Poly\-Data\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Smooth\-Poly\-Data\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Convergence (double )} -\/ Specify a convergence criterion for the iteration process. Smaller numbers result in more smoothing iterations.  
\item {\ttfamily double = obj.\-Get\-Convergence\-Min\-Value ()} -\/ Specify a convergence criterion for the iteration process. Smaller numbers result in more smoothing iterations.  
\item {\ttfamily double = obj.\-Get\-Convergence\-Max\-Value ()} -\/ Specify a convergence criterion for the iteration process. Smaller numbers result in more smoothing iterations.  
\item {\ttfamily double = obj.\-Get\-Convergence ()} -\/ Specify a convergence criterion for the iteration process. Smaller numbers result in more smoothing iterations.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Iterations (int )} -\/ Specify the number of iterations for Laplacian smoothing,  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Iterations\-Min\-Value ()} -\/ Specify the number of iterations for Laplacian smoothing,  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Iterations\-Max\-Value ()} -\/ Specify the number of iterations for Laplacian smoothing,  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Iterations ()} -\/ Specify the number of iterations for Laplacian smoothing,  
\item {\ttfamily obj.\-Set\-Relaxation\-Factor (double )} -\/ Specify the relaxation factor for Laplacian smoothing. As in all iterative methods, the stability of the process is sensitive to this parameter. In general, small relaxation factors and large numbers of iterations are more stable than larger relaxation factors and smaller numbers of iterations.  
\item {\ttfamily double = obj.\-Get\-Relaxation\-Factor ()} -\/ Specify the relaxation factor for Laplacian smoothing. As in all iterative methods, the stability of the process is sensitive to this parameter. In general, small relaxation factors and large numbers of iterations are more stable than larger relaxation factors and smaller numbers of iterations.  
\item {\ttfamily obj.\-Set\-Feature\-Edge\-Smoothing (int )} -\/ Turn on/off smoothing along sharp interior edges.  
\item {\ttfamily int = obj.\-Get\-Feature\-Edge\-Smoothing ()} -\/ Turn on/off smoothing along sharp interior edges.  
\item {\ttfamily obj.\-Feature\-Edge\-Smoothing\-On ()} -\/ Turn on/off smoothing along sharp interior edges.  
\item {\ttfamily obj.\-Feature\-Edge\-Smoothing\-Off ()} -\/ Turn on/off smoothing along sharp interior edges.  
\item {\ttfamily obj.\-Set\-Feature\-Angle (double )} -\/ Specify the feature angle for sharp edge identification.  
\item {\ttfamily double = obj.\-Get\-Feature\-Angle\-Min\-Value ()} -\/ Specify the feature angle for sharp edge identification.  
\item {\ttfamily double = obj.\-Get\-Feature\-Angle\-Max\-Value ()} -\/ Specify the feature angle for sharp edge identification.  
\item {\ttfamily double = obj.\-Get\-Feature\-Angle ()} -\/ Specify the feature angle for sharp edge identification.  
\item {\ttfamily obj.\-Set\-Edge\-Angle (double )} -\/ Specify the edge angle to control smoothing along edges (either interior or boundary).  
\item {\ttfamily double = obj.\-Get\-Edge\-Angle\-Min\-Value ()} -\/ Specify the edge angle to control smoothing along edges (either interior or boundary).  
\item {\ttfamily double = obj.\-Get\-Edge\-Angle\-Max\-Value ()} -\/ Specify the edge angle to control smoothing along edges (either interior or boundary).  
\item {\ttfamily double = obj.\-Get\-Edge\-Angle ()} -\/ Specify the edge angle to control smoothing along edges (either interior or boundary).  
\item {\ttfamily obj.\-Set\-Boundary\-Smoothing (int )} -\/ Turn on/off the smoothing of vertices on the boundary of the mesh.  
\item {\ttfamily int = obj.\-Get\-Boundary\-Smoothing ()} -\/ Turn on/off the smoothing of vertices on the boundary of the mesh.  
\item {\ttfamily obj.\-Boundary\-Smoothing\-On ()} -\/ Turn on/off the smoothing of vertices on the boundary of the mesh.  
\item {\ttfamily obj.\-Boundary\-Smoothing\-Off ()} -\/ Turn on/off the smoothing of vertices on the boundary of the mesh.  
\item {\ttfamily obj.\-Set\-Generate\-Error\-Scalars (int )} -\/ Turn on/off the generation of scalar distance values.  
\item {\ttfamily int = obj.\-Get\-Generate\-Error\-Scalars ()} -\/ Turn on/off the generation of scalar distance values.  
\item {\ttfamily obj.\-Generate\-Error\-Scalars\-On ()} -\/ Turn on/off the generation of scalar distance values.  
\item {\ttfamily obj.\-Generate\-Error\-Scalars\-Off ()} -\/ Turn on/off the generation of scalar distance values.  
\item {\ttfamily obj.\-Set\-Generate\-Error\-Vectors (int )} -\/ Turn on/off the generation of error vectors.  
\item {\ttfamily int = obj.\-Get\-Generate\-Error\-Vectors ()} -\/ Turn on/off the generation of error vectors.  
\item {\ttfamily obj.\-Generate\-Error\-Vectors\-On ()} -\/ Turn on/off the generation of error vectors.  
\item {\ttfamily obj.\-Generate\-Error\-Vectors\-Off ()} -\/ Turn on/off the generation of error vectors.  
\item {\ttfamily obj.\-Set\-Source (vtk\-Poly\-Data source)} -\/ Specify the source object which is used to constrain smoothing. The source defines a surface that the input (as it is smoothed) is constrained to lie upon.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Source ()} -\/ Specify the source object which is used to constrain smoothing. The source defines a surface that the input (as it is smoothed) is constrained to lie upon.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkspatialrepresentationfilter}{}\section{vtk\-Spatial\-Representation\-Filter}\label{vtkgraphics_vtkspatialrepresentationfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Spatial\-Representation\-Filter generates an polygonal representation of a spatial search (vtk\-Locator) object. The representation varies depending upon the nature of the spatial search object. For example, the representation for vtk\-O\-B\-B\-Tree is a collection of oriented bounding boxes. Ths input to this filter is a dataset of any type, and the output is polygonal data. You must also specify the spatial search object to use.

Generally spatial search objects are used for collision detection and other geometric operations, but in this filter one or more levels of spatial searchers can be generated to form a geometric approximation to the input data. This is a form of data simplification, generally used to accelerate the rendering process. Or, this filter can be used as a debugging/ visualization aid for spatial search objects.

This filter can generate one or more output vtk\-Poly\-Data corresponding to different levels in the spatial search tree. The output data is retrieved using the Get\-Output(id) method, where id ranges from 0 (root level) to Level. Note that the output for level \char`\"{}id\char`\"{} is not computed unless a Get\-Output(id) method is issued. Thus, if you desire three levels of output (say 2,4,7), you would have to invoke Get\-Output(2), Get\-Output(4), and Get\-Output(7). (Also note that the Level ivar is computed automatically depending on the size and nature of the input data.) There is also another Get\-Output() method that takes no parameters. This method returns the leafs of the spatial search tree, which may be at different levels.

To create an instance of class vtk\-Spatial\-Representation\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSpatialRepresentationFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Spatial\-Representation\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Spatial\-Representation\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Spatial\-Representation\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Spatial\-Representation\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Spatial\-Representation (vtk\-Locator )} -\/ Set/\-Get the locator that will be used to generate the representation.  
\item {\ttfamily vtk\-Locator = obj.\-Get\-Spatial\-Representation ()} -\/ Set/\-Get the locator that will be used to generate the representation.  
\item {\ttfamily int = obj.\-Get\-Level ()} -\/ Get the maximum number of outputs actually available.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Output (int level)} -\/ A special form of the Get\-Output() method that returns multiple outputs.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Output ()} -\/ Output of terminal nodes/leaves.  
\item {\ttfamily obj.\-Reset\-Output ()} -\/ Reset requested output levels  
\item {\ttfamily obj.\-Set\-Input (vtk\-Data\-Set input)} -\/ Set / get the input data or filter.  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Input ()} -\/ Set / get the input data or filter.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkspherepuzzle}{}\section{vtk\-Sphere\-Puzzle}\label{vtkgraphics_vtkspherepuzzle}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Sphere\-Puzzle creates

To create an instance of class vtk\-Sphere\-Puzzle, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSpherePuzzle
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Sphere\-Puzzle has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Sphere\-Puzzle class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Sphere\-Puzzle = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Sphere\-Puzzle = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Reset ()} -\/ Reset the state of this puzzle back to its original state.  
\item {\ttfamily obj.\-Move\-Horizontal (int section, int percentage, int right\-Flag)} -\/ Move the top/bottom half one segment either direction.  
\item {\ttfamily obj.\-Move\-Vertical (int section, int percentage, int right\-Flag)} -\/ Rotate vertical half of sphere along one of the longitude lines.  
\item {\ttfamily int = obj.\-Set\-Point (double x, double y, double z)} -\/ Set\-Point will be called as the mouse moves over the screen. The output will change to indicate the pending move. Set\-Point returns zero if move is not activated by point. Otherwise it encodes the move into a unique integer so that the caller can determine if the move state has changed. This will answer the question, \char`\"{}\-Should I render.\char`\"{}  
\item {\ttfamily obj.\-Move\-Point (int percentage)} -\/ Move actually implements the pending move. When percentage is 100, the pending move becomes inactive, and Set\-Point will have to be called again to setup another move.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkspherepuzzlearrows}{}\section{vtk\-Sphere\-Puzzle\-Arrows}\label{vtkgraphics_vtkspherepuzzlearrows}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Sphere\-Puzzle\-Arrows creates

To create an instance of class vtk\-Sphere\-Puzzle\-Arrows, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSpherePuzzleArrows
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Sphere\-Puzzle\-Arrows has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Sphere\-Puzzle\-Arrows class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Sphere\-Puzzle\-Arrows = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Sphere\-Puzzle\-Arrows = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Permutation (int \mbox{[}32\mbox{]})} -\/ Permutation is an array of puzzle piece ids. Arrows will be generated for any id that does not contain itself. Permutation\mbox{[}3\mbox{]} = 3 will produce no arrow. Permutation\mbox{[}3\mbox{]} = 10 will draw an arrow from location 3 to 10.  
\item {\ttfamily int = obj. Get\-Permutation ()} -\/ Permutation is an array of puzzle piece ids. Arrows will be generated for any id that does not contain itself. Permutation\mbox{[}3\mbox{]} = 3 will produce no arrow. Permutation\mbox{[}3\mbox{]} = 10 will draw an arrow from location 3 to 10.  
\item {\ttfamily obj.\-Set\-Permutation\-Component (int comp, int val)} -\/ Permutation is an array of puzzle piece ids. Arrows will be generated for any id that does not contain itself. Permutation\mbox{[}3\mbox{]} = 3 will produce no arrow. Permutation\mbox{[}3\mbox{]} = 10 will draw an arrow from location 3 to 10.  
\item {\ttfamily obj.\-Set\-Permutation (vtk\-Sphere\-Puzzle puz)} -\/ Permutation is an array of puzzle piece ids. Arrows will be generated for any id that does not contain itself. Permutation\mbox{[}3\mbox{]} = 3 will produce no arrow. Permutation\mbox{[}3\mbox{]} = 10 will draw an arrow from location 3 to 10.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkspheresource}{}\section{vtk\-Sphere\-Source}\label{vtkgraphics_vtkspheresource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Sphere\-Source creates a sphere (represented by polygons) of specified radius centered at the origin. The resolution (polygonal discretization) in both the latitude (phi) and longitude (theta) directions can be specified. It also is possible to create partial spheres by specifying maximum phi and theta angles. By default, the surface tessellation of the sphere uses triangles; however you can set Lat\-Long\-Tessellation to produce a tessellation using quadrilaterals.

To create an instance of class vtk\-Sphere\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSphereSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Sphere\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Sphere\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Sphere\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Sphere\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Radius (double )} -\/ Set radius of sphere. Default is .5.  
\item {\ttfamily double = obj.\-Get\-Radius\-Min\-Value ()} -\/ Set radius of sphere. Default is .5.  
\item {\ttfamily double = obj.\-Get\-Radius\-Max\-Value ()} -\/ Set radius of sphere. Default is .5.  
\item {\ttfamily double = obj.\-Get\-Radius ()} -\/ Set radius of sphere. Default is .5.  
\item {\ttfamily obj.\-Set\-Center (double , double , double )} -\/ Set the center of the sphere. Default is 0,0,0.  
\item {\ttfamily obj.\-Set\-Center (double a\mbox{[}3\mbox{]})} -\/ Set the center of the sphere. Default is 0,0,0.  
\item {\ttfamily double = obj. Get\-Center ()} -\/ Set the center of the sphere. Default is 0,0,0.  
\item {\ttfamily obj.\-Set\-Theta\-Resolution (int )} -\/ Set the number of points in the longitude direction (ranging from Start\-Theta to End\-Theta).  
\item {\ttfamily int = obj.\-Get\-Theta\-Resolution\-Min\-Value ()} -\/ Set the number of points in the longitude direction (ranging from Start\-Theta to End\-Theta).  
\item {\ttfamily int = obj.\-Get\-Theta\-Resolution\-Max\-Value ()} -\/ Set the number of points in the longitude direction (ranging from Start\-Theta to End\-Theta).  
\item {\ttfamily int = obj.\-Get\-Theta\-Resolution ()} -\/ Set the number of points in the longitude direction (ranging from Start\-Theta to End\-Theta).  
\item {\ttfamily obj.\-Set\-Phi\-Resolution (int )} -\/ Set the number of points in the latitude direction (ranging from Start\-Phi to End\-Phi).  
\item {\ttfamily int = obj.\-Get\-Phi\-Resolution\-Min\-Value ()} -\/ Set the number of points in the latitude direction (ranging from Start\-Phi to End\-Phi).  
\item {\ttfamily int = obj.\-Get\-Phi\-Resolution\-Max\-Value ()} -\/ Set the number of points in the latitude direction (ranging from Start\-Phi to End\-Phi).  
\item {\ttfamily int = obj.\-Get\-Phi\-Resolution ()} -\/ Set the number of points in the latitude direction (ranging from Start\-Phi to End\-Phi).  
\item {\ttfamily obj.\-Set\-Start\-Theta (double )} -\/ Set the starting longitude angle. By default Start\-Theta=0 degrees.  
\item {\ttfamily double = obj.\-Get\-Start\-Theta\-Min\-Value ()} -\/ Set the starting longitude angle. By default Start\-Theta=0 degrees.  
\item {\ttfamily double = obj.\-Get\-Start\-Theta\-Max\-Value ()} -\/ Set the starting longitude angle. By default Start\-Theta=0 degrees.  
\item {\ttfamily double = obj.\-Get\-Start\-Theta ()} -\/ Set the starting longitude angle. By default Start\-Theta=0 degrees.  
\item {\ttfamily obj.\-Set\-End\-Theta (double )} -\/ Set the ending longitude angle. By default End\-Theta=360 degrees.  
\item {\ttfamily double = obj.\-Get\-End\-Theta\-Min\-Value ()} -\/ Set the ending longitude angle. By default End\-Theta=360 degrees.  
\item {\ttfamily double = obj.\-Get\-End\-Theta\-Max\-Value ()} -\/ Set the ending longitude angle. By default End\-Theta=360 degrees.  
\item {\ttfamily double = obj.\-Get\-End\-Theta ()} -\/ Set the ending longitude angle. By default End\-Theta=360 degrees.  
\item {\ttfamily obj.\-Set\-Start\-Phi (double )} -\/ Set the starting latitude angle (0 is at north pole). By default Start\-Phi=0 degrees.  
\item {\ttfamily double = obj.\-Get\-Start\-Phi\-Min\-Value ()} -\/ Set the starting latitude angle (0 is at north pole). By default Start\-Phi=0 degrees.  
\item {\ttfamily double = obj.\-Get\-Start\-Phi\-Max\-Value ()} -\/ Set the starting latitude angle (0 is at north pole). By default Start\-Phi=0 degrees.  
\item {\ttfamily double = obj.\-Get\-Start\-Phi ()} -\/ Set the starting latitude angle (0 is at north pole). By default Start\-Phi=0 degrees.  
\item {\ttfamily obj.\-Set\-End\-Phi (double )} -\/ Set the ending latitude angle. By default End\-Phi=180 degrees.  
\item {\ttfamily double = obj.\-Get\-End\-Phi\-Min\-Value ()} -\/ Set the ending latitude angle. By default End\-Phi=180 degrees.  
\item {\ttfamily double = obj.\-Get\-End\-Phi\-Max\-Value ()} -\/ Set the ending latitude angle. By default End\-Phi=180 degrees.  
\item {\ttfamily double = obj.\-Get\-End\-Phi ()} -\/ Set the ending latitude angle. By default End\-Phi=180 degrees.  
\item {\ttfamily obj.\-Set\-Lat\-Long\-Tessellation (int )} -\/ Cause the sphere to be tessellated with edges along the latitude and longitude lines. If off, triangles are generated at non-\/polar regions, which results in edges that are not parallel to latitude and longitude lines. If on, quadrilaterals are generated everywhere except at the poles. This can be useful for generating a wireframe sphere with natural latitude and longitude lines.  
\item {\ttfamily int = obj.\-Get\-Lat\-Long\-Tessellation ()} -\/ Cause the sphere to be tessellated with edges along the latitude and longitude lines. If off, triangles are generated at non-\/polar regions, which results in edges that are not parallel to latitude and longitude lines. If on, quadrilaterals are generated everywhere except at the poles. This can be useful for generating a wireframe sphere with natural latitude and longitude lines.  
\item {\ttfamily obj.\-Lat\-Long\-Tessellation\-On ()} -\/ Cause the sphere to be tessellated with edges along the latitude and longitude lines. If off, triangles are generated at non-\/polar regions, which results in edges that are not parallel to latitude and longitude lines. If on, quadrilaterals are generated everywhere except at the poles. This can be useful for generating a wireframe sphere with natural latitude and longitude lines.  
\item {\ttfamily obj.\-Lat\-Long\-Tessellation\-Off ()} -\/ Cause the sphere to be tessellated with edges along the latitude and longitude lines. If off, triangles are generated at non-\/polar regions, which results in edges that are not parallel to latitude and longitude lines. If on, quadrilaterals are generated everywhere except at the poles. This can be useful for generating a wireframe sphere with natural latitude and longitude lines.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtksplinefilter}{}\section{vtk\-Spline\-Filter}\label{vtkgraphics_vtksplinefilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Spline\-Filter is a filter that generates an output polylines from an input set of polylines. The polylines are uniformly subdivided and produced with the help of a vtk\-Spline class that the user can specify (by default a vtk\-Cardinal\-Spline is used). The number of subdivisions of the line can be controlled in several ways. The user can either specify the number of subdivisions or a length of each subdivision can be provided (and the class will figure out how many subdivisions is required over the whole polyline). The maximum number of subdivisions can also be set.

The output of this filter is a polyline per input polyline (or line). New points and texture coordinates are created. Point data is interpolated and cell data passed on. Any polylines with less than two points, or who have coincident points, are ignored.

To create an instance of class vtk\-Spline\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSplineFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Spline\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Spline\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Spline\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Spline\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Maximum\-Number\-Of\-Subdivisions (int )} -\/ Set the maximum number of subdivisions that are created for each polyline.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Number\-Of\-Subdivisions\-Min\-Value ()} -\/ Set the maximum number of subdivisions that are created for each polyline.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Number\-Of\-Subdivisions\-Max\-Value ()} -\/ Set the maximum number of subdivisions that are created for each polyline.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Number\-Of\-Subdivisions ()} -\/ Set the maximum number of subdivisions that are created for each polyline.  
\item {\ttfamily obj.\-Set\-Subdivide (int )} -\/ Specify how the number of subdivisions is determined.  
\item {\ttfamily int = obj.\-Get\-Subdivide\-Min\-Value ()} -\/ Specify how the number of subdivisions is determined.  
\item {\ttfamily int = obj.\-Get\-Subdivide\-Max\-Value ()} -\/ Specify how the number of subdivisions is determined.  
\item {\ttfamily int = obj.\-Get\-Subdivide ()} -\/ Specify how the number of subdivisions is determined.  
\item {\ttfamily obj.\-Set\-Subdivide\-To\-Specified ()} -\/ Specify how the number of subdivisions is determined.  
\item {\ttfamily obj.\-Set\-Subdivide\-To\-Length ()} -\/ Specify how the number of subdivisions is determined.  
\item {\ttfamily string = obj.\-Get\-Subdivide\-As\-String ()} -\/ Specify how the number of subdivisions is determined.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Subdivisions (int )} -\/ Set the number of subdivisions that are created for the polyline. This method only has effect if Subdivisions is set to Set\-Subdivisions\-To\-Specify().  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Subdivisions\-Min\-Value ()} -\/ Set the number of subdivisions that are created for the polyline. This method only has effect if Subdivisions is set to Set\-Subdivisions\-To\-Specify().  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Subdivisions\-Max\-Value ()} -\/ Set the number of subdivisions that are created for the polyline. This method only has effect if Subdivisions is set to Set\-Subdivisions\-To\-Specify().  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Subdivisions ()} -\/ Set the number of subdivisions that are created for the polyline. This method only has effect if Subdivisions is set to Set\-Subdivisions\-To\-Specify().  
\item {\ttfamily obj.\-Set\-Length (double )} -\/ Control the number of subdivisions that are created for the polyline based on an absolute length. The length of the spline is divided by this length to determine the number of subdivisions.  
\item {\ttfamily double = obj.\-Get\-Length\-Min\-Value ()} -\/ Control the number of subdivisions that are created for the polyline based on an absolute length. The length of the spline is divided by this length to determine the number of subdivisions.  
\item {\ttfamily double = obj.\-Get\-Length\-Max\-Value ()} -\/ Control the number of subdivisions that are created for the polyline based on an absolute length. The length of the spline is divided by this length to determine the number of subdivisions.  
\item {\ttfamily double = obj.\-Get\-Length ()} -\/ Control the number of subdivisions that are created for the polyline based on an absolute length. The length of the spline is divided by this length to determine the number of subdivisions.  
\item {\ttfamily obj.\-Set\-Spline (vtk\-Spline )} -\/ Specify an instance of vtk\-Spline to use to perform the interpolation.  
\item {\ttfamily vtk\-Spline = obj.\-Get\-Spline ()} -\/ Specify an instance of vtk\-Spline to use to perform the interpolation.  
\item {\ttfamily obj.\-Set\-Generate\-T\-Coords (int )} -\/ Control whether and how texture coordinates are produced. This is useful for striping the output polyline. The texture coordinates can be generated in three ways\-: a normalized (0,1) generation; based on the length (divided by the texture length); and by using the input scalar values.  
\item {\ttfamily int = obj.\-Get\-Generate\-T\-Coords\-Min\-Value ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the output polyline. The texture coordinates can be generated in three ways\-: a normalized (0,1) generation; based on the length (divided by the texture length); and by using the input scalar values.  
\item {\ttfamily int = obj.\-Get\-Generate\-T\-Coords\-Max\-Value ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the output polyline. The texture coordinates can be generated in three ways\-: a normalized (0,1) generation; based on the length (divided by the texture length); and by using the input scalar values.  
\item {\ttfamily int = obj.\-Get\-Generate\-T\-Coords ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the output polyline. The texture coordinates can be generated in three ways\-: a normalized (0,1) generation; based on the length (divided by the texture length); and by using the input scalar values.  
\item {\ttfamily obj.\-Set\-Generate\-T\-Coords\-To\-Off ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the output polyline. The texture coordinates can be generated in three ways\-: a normalized (0,1) generation; based on the length (divided by the texture length); and by using the input scalar values.  
\item {\ttfamily obj.\-Set\-Generate\-T\-Coords\-To\-Normalized\-Length ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the output polyline. The texture coordinates can be generated in three ways\-: a normalized (0,1) generation; based on the length (divided by the texture length); and by using the input scalar values.  
\item {\ttfamily obj.\-Set\-Generate\-T\-Coords\-To\-Use\-Length ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the output polyline. The texture coordinates can be generated in three ways\-: a normalized (0,1) generation; based on the length (divided by the texture length); and by using the input scalar values.  
\item {\ttfamily obj.\-Set\-Generate\-T\-Coords\-To\-Use\-Scalars ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the output polyline. The texture coordinates can be generated in three ways\-: a normalized (0,1) generation; based on the length (divided by the texture length); and by using the input scalar values.  
\item {\ttfamily string = obj.\-Get\-Generate\-T\-Coords\-As\-String ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the output polyline. The texture coordinates can be generated in three ways\-: a normalized (0,1) generation; based on the length (divided by the texture length); and by using the input scalar values.  
\item {\ttfamily obj.\-Set\-Texture\-Length (double )} -\/ Control the conversion of units during the texture coordinates calculation. The Texture\-Length indicates what length (whether calculated from scalars or length) is mapped to the \mbox{[}0,1) texture space.  
\item {\ttfamily double = obj.\-Get\-Texture\-Length\-Min\-Value ()} -\/ Control the conversion of units during the texture coordinates calculation. The Texture\-Length indicates what length (whether calculated from scalars or length) is mapped to the \mbox{[}0,1) texture space.  
\item {\ttfamily double = obj.\-Get\-Texture\-Length\-Max\-Value ()} -\/ Control the conversion of units during the texture coordinates calculation. The Texture\-Length indicates what length (whether calculated from scalars or length) is mapped to the \mbox{[}0,1) texture space.  
\item {\ttfamily double = obj.\-Get\-Texture\-Length ()} -\/ Control the conversion of units during the texture coordinates calculation. The Texture\-Length indicates what length (whether calculated from scalars or length) is mapped to the \mbox{[}0,1) texture space.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtksplitfield}{}\section{vtk\-Split\-Field}\label{vtkgraphics_vtksplitfield}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Split\-Field is used to split a multi-\/component field (vtk\-Data\-Array) into multiple single component fields. The new fields are put in the same field data as the original field. The output arrays are of the same type as the input array. Example\-: \begin{DoxyVerb} sf->SetInputField("gradient", vtkSplitField::POINT_DATA);
 sf->Split(0, "firstcomponent");\end{DoxyVerb}
 tells vtk\-Split\-Field to extract the first component of the field called gradient and create an array called firstcomponent (the new field will be in the output's point data). The same can be done from Tcl\-: \begin{DoxyVerb} sf SetInputField gradient POINT_DATA
 sf Split 0 firstcomponent

 AttributeTypes: SCALARS, VECTORS, NORMALS, TCOORDS, TENSORS
 Field locations: DATA_OBJECT, POINT_DATA, CELL_DATA\end{DoxyVerb}
 Note that, by default, the original array is also passed through.

To create an instance of class vtk\-Split\-Field, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSplitField
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Split\-Field has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Split\-Field class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Split\-Field = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Split\-Field = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Input\-Field (int attribute\-Type, int field\-Loc)} -\/ Use the given attribute in the field data given by field\-Loc as input.  
\item {\ttfamily obj.\-Set\-Input\-Field (string name, int field\-Loc)} -\/ Use the array with given name in the field data given by field\-Loc as input.  
\item {\ttfamily obj.\-Set\-Input\-Field (string name, string field\-Loc)} -\/ Helper method used by other language bindings. Allows the caller to specify arguments as strings instead of enums.  
\item {\ttfamily obj.\-Split (int component, string array\-Name)} -\/ Create a new array with the given component.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkstreamer}{}\section{vtk\-Streamer}\label{vtkgraphics_vtkstreamer}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Streamer is a filter that integrates a massless particle through a vector field. The integration is performed using second order Runge-\/\-Kutta method. vtk\-Streamer often serves as a base class for other classes that perform numerical integration through a vector field (e.\-g., vtk\-Stream\-Line).

Note that vtk\-Streamer can integrate both forward and backward in time, or in both directions. The length of the streamer is controlled by specifying an elapsed time. (The elapsed time is the time each particle travels.) Otherwise, the integration terminates after exiting the dataset or if the particle speed is reduced to a value less than the terminal speed.

vtk\-Streamer integrates through any type of dataset. As a result, if the dataset contains 2\-D cells such as polygons or triangles, the integration is constrained to lie on the surface defined by the 2\-D cells.

The starting point of streamers may be defined in three different ways. Starting from global x-\/y-\/z \char`\"{}position\char`\"{} allows you to start a single streamer at a specified x-\/y-\/z coordinate. Starting from \char`\"{}location\char`\"{} allows you to start at a specified cell, sub\-Id, and parametric coordinate. Finally, you may specify a source object to start multiple streamers. If you start streamers using a source object, for each point in the source that is inside the dataset a streamer is created.

vtk\-Streamer implements the integration process in the Integrate() method. Because vtk\-Streamer does not implement the Execute() method that its superclass (i.\-e., Filter) requires, it is an abstract class. Its subclasses implement the execute method and use the Integrate() method, and then build their own representation of the integration path (i.\-e., lines, dashed lines, points, etc.).

To create an instance of class vtk\-Streamer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkStreamer
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Streamer has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Streamer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Streamer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Streamer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Start\-Location (vtk\-Id\-Type cell\-Id, int sub\-Id, double pcoords\mbox{[}3\mbox{]})} -\/ Specify the start of the streamline in the cell coordinate system. That is, cell\-Id and sub\-Id (if composite cell), and parametric coordinates.  
\item {\ttfamily obj.\-Set\-Start\-Location (vtk\-Id\-Type cell\-Id, int sub\-Id, double r, double s, double t)} -\/ Specify the start of the streamline in the cell coordinate system. That is, cell\-Id and sub\-Id (if composite cell), and parametric coordinates.  
\item {\ttfamily obj.\-Set\-Start\-Position (double x\mbox{[}3\mbox{]})} -\/ Specify the start of the streamline in the global coordinate system. Search must be performed to find initial cell to start integration from.  
\item {\ttfamily obj.\-Set\-Start\-Position (double x, double y, double z)} -\/ Specify the start of the streamline in the global coordinate system. Search must be performed to find initial cell to start integration from.  
\item {\ttfamily double = obj.\-Get\-Start\-Position ()} -\/ Get the start position in global x-\/y-\/z coordinates.  
\item {\ttfamily obj.\-Set\-Source (vtk\-Data\-Set source)} -\/ Specify the source object used to generate starting points.  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Source ()} -\/ Specify the source object used to generate starting points.  
\item {\ttfamily obj.\-Set\-Maximum\-Propagation\-Time (double )} -\/ Specify the maximum length of the Streamer expressed in elapsed time.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Propagation\-Time\-Min\-Value ()} -\/ Specify the maximum length of the Streamer expressed in elapsed time.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Propagation\-Time\-Max\-Value ()} -\/ Specify the maximum length of the Streamer expressed in elapsed time.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Propagation\-Time ()} -\/ Specify the maximum length of the Streamer expressed in elapsed time.  
\item {\ttfamily obj.\-Set\-Integration\-Direction (int )} -\/ Specify the direction in which to integrate the Streamer.  
\item {\ttfamily int = obj.\-Get\-Integration\-Direction\-Min\-Value ()} -\/ Specify the direction in which to integrate the Streamer.  
\item {\ttfamily int = obj.\-Get\-Integration\-Direction\-Max\-Value ()} -\/ Specify the direction in which to integrate the Streamer.  
\item {\ttfamily int = obj.\-Get\-Integration\-Direction ()} -\/ Specify the direction in which to integrate the Streamer.  
\item {\ttfamily obj.\-Set\-Integration\-Direction\-To\-Forward ()} -\/ Specify the direction in which to integrate the Streamer.  
\item {\ttfamily obj.\-Set\-Integration\-Direction\-To\-Backward ()} -\/ Specify the direction in which to integrate the Streamer.  
\item {\ttfamily obj.\-Set\-Integration\-Direction\-To\-Integrate\-Both\-Directions ()} -\/ Specify the direction in which to integrate the Streamer.  
\item {\ttfamily string = obj.\-Get\-Integration\-Direction\-As\-String ()} -\/ Specify the direction in which to integrate the Streamer.  
\item {\ttfamily obj.\-Set\-Integration\-Step\-Length (double )} -\/ Specify a nominal integration step size (expressed as a fraction of the size of each cell). This value can be larger than 1.  
\item {\ttfamily double = obj.\-Get\-Integration\-Step\-Length\-Min\-Value ()} -\/ Specify a nominal integration step size (expressed as a fraction of the size of each cell). This value can be larger than 1.  
\item {\ttfamily double = obj.\-Get\-Integration\-Step\-Length\-Max\-Value ()} -\/ Specify a nominal integration step size (expressed as a fraction of the size of each cell). This value can be larger than 1.  
\item {\ttfamily double = obj.\-Get\-Integration\-Step\-Length ()} -\/ Specify a nominal integration step size (expressed as a fraction of the size of each cell). This value can be larger than 1.  
\item {\ttfamily obj.\-Set\-Speed\-Scalars (int )} -\/ Turn on/off the creation of scalar data from velocity magnitude. If off, and input dataset has scalars, input dataset scalars are used.  
\item {\ttfamily int = obj.\-Get\-Speed\-Scalars ()} -\/ Turn on/off the creation of scalar data from velocity magnitude. If off, and input dataset has scalars, input dataset scalars are used.  
\item {\ttfamily obj.\-Speed\-Scalars\-On ()} -\/ Turn on/off the creation of scalar data from velocity magnitude. If off, and input dataset has scalars, input dataset scalars are used.  
\item {\ttfamily obj.\-Speed\-Scalars\-Off ()} -\/ Turn on/off the creation of scalar data from velocity magnitude. If off, and input dataset has scalars, input dataset scalars are used.  
\item {\ttfamily obj.\-Set\-Orientation\-Scalars (int )} -\/ Turn on/off the creation of scalar data from vorticity information. The scalar information is currently the orientation value \char`\"{}theta\char`\"{} used in rotating stream tubes. If off, and input dataset has scalars, then input dataset scalars are used, unless Speed\-Scalars is also on. Speed\-Scalars takes precedence over Orientation\-Scalars.  
\item {\ttfamily int = obj.\-Get\-Orientation\-Scalars ()} -\/ Turn on/off the creation of scalar data from vorticity information. The scalar information is currently the orientation value \char`\"{}theta\char`\"{} used in rotating stream tubes. If off, and input dataset has scalars, then input dataset scalars are used, unless Speed\-Scalars is also on. Speed\-Scalars takes precedence over Orientation\-Scalars.  
\item {\ttfamily obj.\-Orientation\-Scalars\-On ()} -\/ Turn on/off the creation of scalar data from vorticity information. The scalar information is currently the orientation value \char`\"{}theta\char`\"{} used in rotating stream tubes. If off, and input dataset has scalars, then input dataset scalars are used, unless Speed\-Scalars is also on. Speed\-Scalars takes precedence over Orientation\-Scalars.  
\item {\ttfamily obj.\-Orientation\-Scalars\-Off ()} -\/ Turn on/off the creation of scalar data from vorticity information. The scalar information is currently the orientation value \char`\"{}theta\char`\"{} used in rotating stream tubes. If off, and input dataset has scalars, then input dataset scalars are used, unless Speed\-Scalars is also on. Speed\-Scalars takes precedence over Orientation\-Scalars.  
\item {\ttfamily obj.\-Set\-Terminal\-Speed (double )} -\/ Set/get terminal speed (i.\-e., speed is velocity magnitude). Terminal speed is speed at which streamer will terminate propagation.  
\item {\ttfamily double = obj.\-Get\-Terminal\-Speed\-Min\-Value ()} -\/ Set/get terminal speed (i.\-e., speed is velocity magnitude). Terminal speed is speed at which streamer will terminate propagation.  
\item {\ttfamily double = obj.\-Get\-Terminal\-Speed\-Max\-Value ()} -\/ Set/get terminal speed (i.\-e., speed is velocity magnitude). Terminal speed is speed at which streamer will terminate propagation.  
\item {\ttfamily double = obj.\-Get\-Terminal\-Speed ()} -\/ Set/get terminal speed (i.\-e., speed is velocity magnitude). Terminal speed is speed at which streamer will terminate propagation.  
\item {\ttfamily obj.\-Set\-Vorticity (int )} -\/ Turn on/off the computation of vorticity. Vorticity is an indication of the rotation of the flow. In combination with vtk\-Stream\-Line and vtk\-Tube\-Filter can be used to create rotated tubes. If vorticity is turned on, in the output, the velocity vectors are replaced by vorticity vectors.  
\item {\ttfamily int = obj.\-Get\-Vorticity ()} -\/ Turn on/off the computation of vorticity. Vorticity is an indication of the rotation of the flow. In combination with vtk\-Stream\-Line and vtk\-Tube\-Filter can be used to create rotated tubes. If vorticity is turned on, in the output, the velocity vectors are replaced by vorticity vectors.  
\item {\ttfamily obj.\-Vorticity\-On ()} -\/ Turn on/off the computation of vorticity. Vorticity is an indication of the rotation of the flow. In combination with vtk\-Stream\-Line and vtk\-Tube\-Filter can be used to create rotated tubes. If vorticity is turned on, in the output, the velocity vectors are replaced by vorticity vectors.  
\item {\ttfamily obj.\-Vorticity\-Off ()} -\/ Turn on/off the computation of vorticity. Vorticity is an indication of the rotation of the flow. In combination with vtk\-Stream\-Line and vtk\-Tube\-Filter can be used to create rotated tubes. If vorticity is turned on, in the output, the velocity vectors are replaced by vorticity vectors.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Threads (int )}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Threads ()}  
\item {\ttfamily obj.\-Set\-Save\-Point\-Interval (double )}  
\item {\ttfamily double = obj.\-Get\-Save\-Point\-Interval ()}  
\item {\ttfamily obj.\-Set\-Integrator (vtk\-Initial\-Value\-Problem\-Solver )} -\/ Set/get the integrator type to be used in the stream line calculation. The object passed is not actually used but is cloned with New\-Instance by each thread/process in the process of integration (prototype pattern). The default is 2nd order Runge Kutta.  
\item {\ttfamily vtk\-Initial\-Value\-Problem\-Solver = obj.\-Get\-Integrator ()} -\/ Set/get the integrator type to be used in the stream line calculation. The object passed is not actually used but is cloned with New\-Instance by each thread/process in the process of integration (prototype pattern). The default is 2nd order Runge Kutta.  
\item {\ttfamily obj.\-Set\-Epsilon (double )} -\/ A positive value, as small as possible for numerical comparison. The initial value is 1\-E-\/12.  
\item {\ttfamily double = obj.\-Get\-Epsilon ()} -\/ A positive value, as small as possible for numerical comparison. The initial value is 1\-E-\/12.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkstreamingtessellator}{}\section{vtk\-Streaming\-Tessellator}\label{vtkgraphics_vtkstreamingtessellator}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is a simple algorithm that takes a single starting simplex -- a tetrahedron, triangle, or line segment -- and calls a function you pass it with (possibly many times) tetrahedra, triangles, or lines adaptively sampled from the one you specified. It uses an algorithm you specify to control the level of adaptivity.

This class does not create vtk\-Unstructured\-Grid output because it is intended for use in mappers as well as filters. Instead, it calls the registered function with simplices as they are created.

The subdivision algorithm should change the vertex coordinates (it must change both geometric and, if desired, parametric coordinates) of the midpoint. These coordinates need not be changed unless the Evaluate\-Edge() member returns true. The vtk\-Streaming\-Tessellator itself has no way of creating a more accurate midpoint vertex.

Here's how to use this class\-:
\begin{DoxyItemize}
\item Call Adaptively\-Sample1\-Facet, Adaptively\-Sample2\-Facet, or Adaptively\-Sample3\-Facet, with an edge, triangle, or tetrahedron you want tessellated.
\item The adaptive tessellator classifies each edge by passing the midpoint values to the vtk\-Edge\-Subdivision\-Criterion.
\item After each edge is classified, the tessellator subdivides edges as required until the subdivision criterion is satisfied or the maximum subdivision depth has been reached.
\item Edges, triangles, or tetrahedra connecting the vertices generated by the subdivision algorithm are processed by calling the user-\/defined callback functions (set with Set\-Tetrahedron\-Callback(), Set\-Triangle\-Callback(), or Set\-Edge\-Callback() ).
\end{DoxyItemize}

.S\-E\-C\-T\-I\-O\-N Warning Note that the vertices passed to Adaptively\-Sample3\-Facet, Adaptively\-Sample2\-Facet, or Adaptively\-Sample1\-Facet must be at least 6, 5, or 4 entries long, respectively! This is because the $<$r,s,t$>$, $<$r,s$>$, or $<$r$>$ parametric coordinates of the vertices are maintained as the facet is subdivided. This information is often required by the subdivision algorithm in order to compute an error metric. You may change the number of parametric coordinates associated with each vertex using vtk\-Streaming\-Tessellator\-::\-Set\-Embedding\-Dimension().

.S\-E\-C\-T\-I\-O\-N Interpolating Field Values If you wish, you may also use {\ttfamily vtk\-Streaming\-Tessellator} to interpolate field values at newly created vertices. Interpolated field values are stored just beyond the parametric coordinates associated with a vertex. They will always be {\ttfamily double} values; it does not make sense to interpolate a boolean or string value and your output and subdivision subroutines may always cast to a {\ttfamily float} or use {\ttfamily floor()} to truncate an interpolated value to an integer.

To create an instance of class vtk\-Streaming\-Tessellator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkStreamingTessellator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Streaming\-Tessellator has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Streaming\-Tessellator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Streaming\-Tessellator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Streaming\-Tessellator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Subdivision\-Algorithm (vtk\-Edge\-Subdivision\-Criterion )} -\/ Get/\-Set the algorithm used to determine whether an edge should be subdivided or left as-\/is. This is used once for each call to Adaptively\-Sample1\-Facet (which is recursive and will call itself resulting in additional edges to be checked) or three times for each call to Adaptively\-Sample2\-Facet (also recursive).  
\item {\ttfamily vtk\-Edge\-Subdivision\-Criterion = obj.\-Get\-Subdivision\-Algorithm ()} -\/ Get/\-Set the algorithm used to determine whether an edge should be subdivided or left as-\/is. This is used once for each call to Adaptively\-Sample1\-Facet (which is recursive and will call itself resulting in additional edges to be checked) or three times for each call to Adaptively\-Sample2\-Facet (also recursive).  
\item {\ttfamily obj.\-Set\-Embedding\-Dimension (int k, int d)} -\/ Get/\-Set the number of parameter-\/space coordinates associated with each input and output point. The default is {\itshape k} for {\itshape k} -\/facets. You may specify a different dimension, {\itshape d}, for each type of {\itshape k} -\/facet to be processed. For example, {\ttfamily Set\-Embedding\-Dimension}( {\ttfamily 2}, {\ttfamily 3} ) would associate {\itshape r}, {\itshape s}, and {\itshape t} coordinates with each input and output point generated by {\ttfamily Adaptively\-Sample2\-Facet} but does not say anything about input or output points generated by {\ttfamily Adaptively\-Sample1\-Facet}. Call {\ttfamily Set\-Embedding\-Dimension}( {\ttfamily -\/1}, {\itshape d} ) to specify the same dimension for all possible {\itshape k} values. {\itshape d} may not exceed 8, as that would be plain silly.  
\item {\ttfamily int = obj.\-Get\-Embedding\-Dimension (int k) const} -\/ Get/\-Set the number of parameter-\/space coordinates associated with each input and output point. The default is {\itshape k} for {\itshape k} -\/facets. You may specify a different dimension, {\itshape d}, for each type of {\itshape k} -\/facet to be processed. For example, {\ttfamily Set\-Embedding\-Dimension}( {\ttfamily 2}, {\ttfamily 3} ) would associate {\itshape r}, {\itshape s}, and {\itshape t} coordinates with each input and output point generated by {\ttfamily Adaptively\-Sample2\-Facet} but does not say anything about input or output points generated by {\ttfamily Adaptively\-Sample1\-Facet}. Call {\ttfamily Set\-Embedding\-Dimension}( {\ttfamily -\/1}, {\itshape d} ) to specify the same dimension for all possible {\itshape k} values. {\itshape d} may not exceed 8, as that would be plain silly.  
\item {\ttfamily obj.\-Set\-Field\-Size (int k, int s)} -\/ Get/\-Set the number of field value coordinates associated with each input and output point. The default is 0; no field values are interpolated. You may specify a different size, {\itshape s}, for each type of {\itshape k} -\/facet to be processed. For example, {\ttfamily Set\-Field\-Size}( {\ttfamily 2}, {\ttfamily 3} ) would associate 3 field value coordinates with each input and output point of an {\ttfamily Adaptively\-Sample2\-Facet} call, but does not say anything about input or output points of {\ttfamily Adaptively\-Sample1\-Facet}. Call {\ttfamily Set\-Field\-Size}( {\ttfamily -\/1}, {\itshape s} ) to specify the same dimension for all possible {\itshape k} values. {\itshape s} may not exceed vtk\-Streaming\-Tessellator\-::\-Max\-Field\-Size. This is a compile-\/time constant that defaults to 18, which is large enough for a scalar, vector, tensor, normal, and texture coordinate to be included at each point.

Normally, you will not call {\itshape Set\-Field\-Size()} directly; instead, subclasses of vtk\-Edge\-Subdivision\-Criterion, such as vtk\-Shoe\-Mesh\-Subdivision\-Algorithm, will call it for you.

In any event, setting {\itshape Field\-Size} to a non-\/zero value means you must pass field values to the {\ttfamily Adaptively\-Samplek\-Facet} routines; For example, \begin{DoxyVerb}    vtkStreamingTessellator* t = vtkStreamingTessellator::New();
    t->SetFieldSize( 1, 3 );
    t->SetEmbeddingDimension( 1, 1 ); // not really required, this is the default
    double p0[3+1+3] = { x0, y0, z0, r0, fx0, fy0, fz0 };
    double p1[3+1+3] = { x1, y1, z1, r1, fx1, fy1, fz1 };
    t->AdaptivelySample1Facet( p0, p1 );\end{DoxyVerb}
 This would adaptively sample an curve (1-\/facet) with geometry and a vector field at every output point on the curve.  
\item {\ttfamily int = obj.\-Get\-Field\-Size (int k) const} -\/ Get/\-Set the number of field value coordinates associated with each input and output point. The default is 0; no field values are interpolated. You may specify a different size, {\itshape s}, for each type of {\itshape k} -\/facet to be processed. For example, {\ttfamily Set\-Field\-Size}( {\ttfamily 2}, {\ttfamily 3} ) would associate 3 field value coordinates with each input and output point of an {\ttfamily Adaptively\-Sample2\-Facet} call, but does not say anything about input or output points of {\ttfamily Adaptively\-Sample1\-Facet}. Call {\ttfamily Set\-Field\-Size}( {\ttfamily -\/1}, {\itshape s} ) to specify the same dimension for all possible {\itshape k} values. {\itshape s} may not exceed vtk\-Streaming\-Tessellator\-::\-Max\-Field\-Size. This is a compile-\/time constant that defaults to 18, which is large enough for a scalar, vector, tensor, normal, and texture coordinate to be included at each point.

Normally, you will not call {\itshape Set\-Field\-Size()} directly; instead, subclasses of vtk\-Edge\-Subdivision\-Criterion, such as vtk\-Shoe\-Mesh\-Subdivision\-Algorithm, will call it for you.

In any event, setting {\itshape Field\-Size} to a non-\/zero value means you must pass field values to the {\ttfamily Adaptively\-Samplek\-Facet} routines; For example, \begin{DoxyVerb}    vtkStreamingTessellator* t = vtkStreamingTessellator::New();
    t->SetFieldSize( 1, 3 );
    t->SetEmbeddingDimension( 1, 1 ); // not really required, this is the default
    double p0[3+1+3] = { x0, y0, z0, r0, fx0, fy0, fz0 };
    double p1[3+1+3] = { x1, y1, z1, r1, fx1, fy1, fz1 };
    t->AdaptivelySample1Facet( p0, p1 );\end{DoxyVerb}
 This would adaptively sample an curve (1-\/facet) with geometry and a vector field at every output point on the curve.  
\item {\ttfamily obj.\-Set\-Maximum\-Number\-Of\-Subdivisions (int num\-\_\-subdiv\-\_\-in)} -\/ Get/\-Set the maximum number of subdivisions that may occur.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Number\-Of\-Subdivisions ()} -\/ Get/\-Set the maximum number of subdivisions that may occur.  
\item {\ttfamily obj.\-Adaptively\-Sample3\-Facet (double v1, double v2, double v3, double v4) const} -\/ This will adaptively subdivide the tetrahedron (3-\/facet), triangle (2-\/facet), or edge (1-\/facet) until the subdivision algorithm returns false for every edge or the maximum recursion depth is reached.

Use {\ttfamily Set\-Maximum\-Number\-Of\-Subdivisions} to change the maximum recursion depth.

The Adaptively\-Sample0\-Facet method is provided as a convenience. Obviously, there is no way to adaptively subdivide a vertex. Instead the input vertex is passed unchanged to the output via a call to the registered Vertex\-Processor\-Function callback.

.S\-E\-C\-T\-I\-O\-N Warning This assumes that you have called Set\-Subdivision\-Algorithm(), Set\-Edge\-Callback(), Set\-Triangle\-Callback(), and Set\-Tetrahedron\-Callback() with valid values!  
\item {\ttfamily obj.\-Adaptively\-Sample2\-Facet (double v1, double v2, double v3) const} -\/ This will adaptively subdivide the tetrahedron (3-\/facet), triangle (2-\/facet), or edge (1-\/facet) until the subdivision algorithm returns false for every edge or the maximum recursion depth is reached.

Use {\ttfamily Set\-Maximum\-Number\-Of\-Subdivisions} to change the maximum recursion depth.

The Adaptively\-Sample0\-Facet method is provided as a convenience. Obviously, there is no way to adaptively subdivide a vertex. Instead the input vertex is passed unchanged to the output via a call to the registered Vertex\-Processor\-Function callback.

.S\-E\-C\-T\-I\-O\-N Warning This assumes that you have called Set\-Subdivision\-Algorithm(), Set\-Edge\-Callback(), Set\-Triangle\-Callback(), and Set\-Tetrahedron\-Callback() with valid values!  
\item {\ttfamily obj.\-Adaptively\-Sample1\-Facet (double v1, double v2) const} -\/ This will adaptively subdivide the tetrahedron (3-\/facet), triangle (2-\/facet), or edge (1-\/facet) until the subdivision algorithm returns false for every edge or the maximum recursion depth is reached.

Use {\ttfamily Set\-Maximum\-Number\-Of\-Subdivisions} to change the maximum recursion depth.

The Adaptively\-Sample0\-Facet method is provided as a convenience. Obviously, there is no way to adaptively subdivide a vertex. Instead the input vertex is passed unchanged to the output via a call to the registered Vertex\-Processor\-Function callback.

.S\-E\-C\-T\-I\-O\-N Warning This assumes that you have called Set\-Subdivision\-Algorithm(), Set\-Edge\-Callback(), Set\-Triangle\-Callback(), and Set\-Tetrahedron\-Callback() with valid values!  
\item {\ttfamily obj.\-Adaptively\-Sample0\-Facet (double v1) const} -\/ This will adaptively subdivide the tetrahedron (3-\/facet), triangle (2-\/facet), or edge (1-\/facet) until the subdivision algorithm returns false for every edge or the maximum recursion depth is reached.

Use {\ttfamily Set\-Maximum\-Number\-Of\-Subdivisions} to change the maximum recursion depth.

The Adaptively\-Sample0\-Facet method is provided as a convenience. Obviously, there is no way to adaptively subdivide a vertex. Instead the input vertex is passed unchanged to the output via a call to the registered Vertex\-Processor\-Function callback.

.S\-E\-C\-T\-I\-O\-N Warning This assumes that you have called Set\-Subdivision\-Algorithm(), Set\-Edge\-Callback(), Set\-Triangle\-Callback(), and Set\-Tetrahedron\-Callback() with valid values!  
\item {\ttfamily obj.\-Reset\-Counts ()} -\/ Reset/access the histogram of subdivision cases encountered. The histogram may be used to examine coverage during testing as well as characterizing the tessellation algorithm's performance. You should call Reset\-Counts() once, at the beginning of a stream of tetrahedra. It must be called before Adaptively\-Sample3\-Facet() to prevent uninitialized memory reads.

These functions have no effect (and return 0) when P\-A\-R\-A\-V\-I\-E\-W\-\_\-\-D\-E\-B\-U\-G\-\_\-\-T\-E\-S\-S\-E\-L\-L\-A\-T\-O\-R has not been defined. By default, P\-A\-R\-A\-V\-I\-E\-W\-\_\-\-D\-E\-B\-U\-G\-\_\-\-T\-E\-S\-S\-E\-L\-L\-A\-T\-O\-R is not defined, and your code will be fast and efficient. Really!  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Case\-Count (int c)} -\/ Reset/access the histogram of subdivision cases encountered. The histogram may be used to examine coverage during testing as well as characterizing the tessellation algorithm's performance. You should call Reset\-Counts() once, at the beginning of a stream of tetrahedra. It must be called before Adaptively\-Sample3\-Facet() to prevent uninitialized memory reads.

These functions have no effect (and return 0) when P\-A\-R\-A\-V\-I\-E\-W\-\_\-\-D\-E\-B\-U\-G\-\_\-\-T\-E\-S\-S\-E\-L\-L\-A\-T\-O\-R has not been defined. By default, P\-A\-R\-A\-V\-I\-E\-W\-\_\-\-D\-E\-B\-U\-G\-\_\-\-T\-E\-S\-S\-E\-L\-L\-A\-T\-O\-R is not defined, and your code will be fast and efficient. Really!  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Subcase\-Count (int casenum, int sub)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkstreamline}{}\section{vtk\-Stream\-Line}\label{vtkgraphics_vtkstreamline}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Stream\-Line is a filter that generates a streamline for an arbitrary dataset. A streamline is a line that is everywhere tangent to the vector field. Scalar values also are calculated along the streamline and can be used to color the line. Streamlines are calculated by integrating from a starting point through the vector field. Integration can be performed forward in time (see where the line goes), backward in time (see where the line came from), or in both directions. It also is possible to compute vorticity along the streamline. Vorticity is the projection (i.\-e., dot product) of the flow rotation on the velocity vector, i.\-e., the rotation of flow around the streamline.

vtk\-Stream\-Line defines the instance variable Step\-Length. This parameter controls the time increment used to generate individual points along the streamline(s). Smaller values result in more line primitives but smoother streamlines. The Step\-Length instance variable is defined in terms of time (i.\-e., the distance that the particle travels in the specified time period). Thus, the line segments will be smaller in areas of low velocity and larger in regions of high velocity. (N\-O\-T\-E\-: This is different than the Integration\-Step\-Length defined by the superclass vtk\-Streamer. Integration\-Step\-Length is used to control integration step size and is expressed as a fraction of the cell length.) The Step\-Length instance variable is important because subclasses of vtk\-Stream\-Line (e.\-g., vtk\-Dashed\-Stream\-Line) depend on this value to build their representation.

To create an instance of class vtk\-Stream\-Line, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkStreamLine
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Stream\-Line has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Stream\-Line class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Stream\-Line = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Stream\-Line = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Step\-Length (double )} -\/ Specify the length of a line segment. The length is expressed in terms of elapsed time. Smaller values result in smoother appearing streamlines, but greater numbers of line primitives.  
\item {\ttfamily double = obj.\-Get\-Step\-Length\-Min\-Value ()} -\/ Specify the length of a line segment. The length is expressed in terms of elapsed time. Smaller values result in smoother appearing streamlines, but greater numbers of line primitives.  
\item {\ttfamily double = obj.\-Get\-Step\-Length\-Max\-Value ()} -\/ Specify the length of a line segment. The length is expressed in terms of elapsed time. Smaller values result in smoother appearing streamlines, but greater numbers of line primitives.  
\item {\ttfamily double = obj.\-Get\-Step\-Length ()} -\/ Specify the length of a line segment. The length is expressed in terms of elapsed time. Smaller values result in smoother appearing streamlines, but greater numbers of line primitives.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkstreampoints}{}\section{vtk\-Stream\-Points}\label{vtkgraphics_vtkstreampoints}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Stream\-Points is a filter that generates points along a streamer. The points are separated by a constant time increment. The resulting visual effect (especially when coupled with vtk\-Glyph3\-D) is an indication of particle speed.

To create an instance of class vtk\-Stream\-Points, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkStreamPoints
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Stream\-Points has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Stream\-Points class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Stream\-Points = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Stream\-Points = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Time\-Increment (double )} -\/ Specify the separation of points in terms of absolute time.  
\item {\ttfamily double = obj.\-Get\-Time\-Increment\-Min\-Value ()} -\/ Specify the separation of points in terms of absolute time.  
\item {\ttfamily double = obj.\-Get\-Time\-Increment\-Max\-Value ()} -\/ Specify the separation of points in terms of absolute time.  
\item {\ttfamily double = obj.\-Get\-Time\-Increment ()} -\/ Specify the separation of points in terms of absolute time.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkstreamtracer}{}\section{vtk\-Stream\-Tracer}\label{vtkgraphics_vtkstreamtracer}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Stream\-Tracer is a filter that integrates a vector field to generate streamlines. The integration is performed using a specified integrator, by default Runge-\/\-Kutta2.

vtk\-Stream\-Tracer produces polylines as the output, with each cell (i.\-e., polyline) representing a streamline. The attribute values associated with each streamline are stored in the cell data, whereas those associated with streamline-\/points are stored in the point data.

vtk\-Stream\-Tracer supports forward (the default), backward, and combined (i.\-e., B\-O\-T\-H) integration. The length of a streamline is governed by specifying a maximum value either in physical arc length or in (local) cell length. Otherwise, the integration terminates upon exiting the flow field domain, or if the particle speed is reduced to a value less than a specified terminal speed, or when a maximum number of steps is completed. The specific reason for the termination is stored in a cell array named Reason\-For\-Termination.

Note that normalized vectors are adopted in streamline integration, which achieves high numerical accuracy/smoothness of flow lines that is particularly guranteed for Runge-\/\-Kutta45 with adaptive step size and error control). In support of this feature, the underlying step size is A\-L\-W\-A\-Y\-S in arc length unit (L\-E\-N\-G\-T\-H\-\_\-\-U\-N\-I\-T) while the 'real' time interval (virtual for steady flows) that a particle actually takes to trave in a single step is obtained by dividing the arc length by the L\-O\-C\-A\-L speed. The overall elapsed time (i.\-e., the life span) of the particle is the sum of those individual step-\/wise time intervals.

The quality of streamline integration can be controlled by setting the initial integration step (Initial\-Integration\-Step), particularly for Runge-\/\-Kutta2 and Runge-\/\-Kutta4 (with a fixed step size), and in the case of Runge-\/\-Kutta45 (with an adaptive step size and error control) the minimum integration step, the maximum integration step, and the maximum error. These steps are in either L\-E\-N\-G\-T\-H\-\_\-\-U\-N\-I\-T or C\-E\-L\-L\-\_\-\-L\-E\-N\-G\-T\-H\-\_\-\-U\-N\-I\-T while the error is in physical arc length. For the former two integrators, there is a trade-\/off between integration speed and streamline quality.

The integration time, vorticity, rotation and angular velocity are stored in point data arrays named \char`\"{}\-Integration\-Time\char`\"{}, \char`\"{}\-Vorticity\char`\"{}, \char`\"{}\-Rotation\char`\"{} and \char`\"{}\-Angular\-Velocity\char`\"{}, respectively (vorticity, rotation and angular velocity are computed only when Compute\-Vorticity is on). All point data attributes in the source dataset are interpolated on the new streamline points.

vtk\-Stream\-Tracer supports integration through any type of dataset. Thus if the dataset contains 2\-D cells like polygons or triangles, the integration is constrained to lie on the surface defined by 2\-D cells.

The starting point, or the so-\/called 'seed', of a streamline may be set in two different ways. Starting from global x-\/y-\/z \char`\"{}position\char`\"{} allows you to start a single trace at a specified x-\/y-\/z coordinate. If you specify a source object, traces will be generated from each point in the source that is inside the dataset.

To create an instance of class vtk\-Stream\-Tracer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkStreamTracer
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Stream\-Tracer has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Stream\-Tracer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Stream\-Tracer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Stream\-Tracer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Start\-Position (double , double , double )} -\/ Specify the starting point (seed) of a streamline in the global coordinate system. Search must be performed to find the initial cell from which to start integration.  
\item {\ttfamily obj.\-Set\-Start\-Position (double a\mbox{[}3\mbox{]})} -\/ Specify the starting point (seed) of a streamline in the global coordinate system. Search must be performed to find the initial cell from which to start integration.  
\item {\ttfamily double = obj. Get\-Start\-Position ()} -\/ Specify the starting point (seed) of a streamline in the global coordinate system. Search must be performed to find the initial cell from which to start integration.  
\item {\ttfamily obj.\-Set\-Source (vtk\-Data\-Set source)} -\/ Specify the source object used to generate starting points (seeds). Old style. Do not use.  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Source ()} -\/ Specify the source object used to generate starting points (seeds). Old style. Do not use.  
\item {\ttfamily obj.\-Set\-Source\-Connection (vtk\-Algorithm\-Output alg\-Output)} -\/ Specify the source object used to generate starting points (seeds). New style.  
\item {\ttfamily obj.\-Set\-Integrator (vtk\-Initial\-Value\-Problem\-Solver )} -\/ Set/get the integrator type to be used for streamline generation. The object passed is not actually used but is cloned with New\-Instance in the process of integration (prototype pattern). The default is Runge-\/\-Kutta2. The integrator can also be changed using Set\-Integrator\-Type. The recognized solvers are\-: R\-U\-N\-G\-E\-\_\-\-K\-U\-T\-T\-A2 = 0 R\-U\-N\-G\-E\-\_\-\-K\-U\-T\-T\-A4 = 1 R\-U\-N\-G\-E\-\_\-\-K\-U\-T\-T\-A45 = 2  
\item {\ttfamily vtk\-Initial\-Value\-Problem\-Solver = obj.\-Get\-Integrator ()} -\/ Set/get the integrator type to be used for streamline generation. The object passed is not actually used but is cloned with New\-Instance in the process of integration (prototype pattern). The default is Runge-\/\-Kutta2. The integrator can also be changed using Set\-Integrator\-Type. The recognized solvers are\-: R\-U\-N\-G\-E\-\_\-\-K\-U\-T\-T\-A2 = 0 R\-U\-N\-G\-E\-\_\-\-K\-U\-T\-T\-A4 = 1 R\-U\-N\-G\-E\-\_\-\-K\-U\-T\-T\-A45 = 2  
\item {\ttfamily obj.\-Set\-Integrator\-Type (int type)} -\/ Set/get the integrator type to be used for streamline generation. The object passed is not actually used but is cloned with New\-Instance in the process of integration (prototype pattern). The default is Runge-\/\-Kutta2. The integrator can also be changed using Set\-Integrator\-Type. The recognized solvers are\-: R\-U\-N\-G\-E\-\_\-\-K\-U\-T\-T\-A2 = 0 R\-U\-N\-G\-E\-\_\-\-K\-U\-T\-T\-A4 = 1 R\-U\-N\-G\-E\-\_\-\-K\-U\-T\-T\-A45 = 2  
\item {\ttfamily int = obj.\-Get\-Integrator\-Type ()} -\/ Set/get the integrator type to be used for streamline generation. The object passed is not actually used but is cloned with New\-Instance in the process of integration (prototype pattern). The default is Runge-\/\-Kutta2. The integrator can also be changed using Set\-Integrator\-Type. The recognized solvers are\-: R\-U\-N\-G\-E\-\_\-\-K\-U\-T\-T\-A2 = 0 R\-U\-N\-G\-E\-\_\-\-K\-U\-T\-T\-A4 = 1 R\-U\-N\-G\-E\-\_\-\-K\-U\-T\-T\-A45 = 2  
\item {\ttfamily obj.\-Set\-Integrator\-Type\-To\-Runge\-Kutta2 ()} -\/ Set/get the integrator type to be used for streamline generation. The object passed is not actually used but is cloned with New\-Instance in the process of integration (prototype pattern). The default is Runge-\/\-Kutta2. The integrator can also be changed using Set\-Integrator\-Type. The recognized solvers are\-: R\-U\-N\-G\-E\-\_\-\-K\-U\-T\-T\-A2 = 0 R\-U\-N\-G\-E\-\_\-\-K\-U\-T\-T\-A4 = 1 R\-U\-N\-G\-E\-\_\-\-K\-U\-T\-T\-A45 = 2  
\item {\ttfamily obj.\-Set\-Integrator\-Type\-To\-Runge\-Kutta4 ()} -\/ Set/get the integrator type to be used for streamline generation. The object passed is not actually used but is cloned with New\-Instance in the process of integration (prototype pattern). The default is Runge-\/\-Kutta2. The integrator can also be changed using Set\-Integrator\-Type. The recognized solvers are\-: R\-U\-N\-G\-E\-\_\-\-K\-U\-T\-T\-A2 = 0 R\-U\-N\-G\-E\-\_\-\-K\-U\-T\-T\-A4 = 1 R\-U\-N\-G\-E\-\_\-\-K\-U\-T\-T\-A45 = 2  
\item {\ttfamily obj.\-Set\-Integrator\-Type\-To\-Runge\-Kutta45 ()} -\/ Set/get the integrator type to be used for streamline generation. The object passed is not actually used but is cloned with New\-Instance in the process of integration (prototype pattern). The default is Runge-\/\-Kutta2. The integrator can also be changed using Set\-Integrator\-Type. The recognized solvers are\-: R\-U\-N\-G\-E\-\_\-\-K\-U\-T\-T\-A2 = 0 R\-U\-N\-G\-E\-\_\-\-K\-U\-T\-T\-A4 = 1 R\-U\-N\-G\-E\-\_\-\-K\-U\-T\-T\-A45 = 2  
\item {\ttfamily obj.\-Set\-Interpolator\-Type\-To\-Data\-Set\-Point\-Locator ()} -\/ Set the velocity field interpolator type to the one involving a dataset point locator.  
\item {\ttfamily obj.\-Set\-Interpolator\-Type\-To\-Cell\-Locator ()} -\/ Set the velocity field interpolator type to the one involving a cell locator.  
\item {\ttfamily obj.\-Set\-Maximum\-Propagation (double max)} -\/ Specify the maximum length of a streamline expressed in L\-E\-N\-G\-T\-H\-\_\-\-U\-N\-I\-T.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Propagation ()} -\/ Specify a uniform integration step unit for Minimum\-Integration\-Step, Initial\-Integration\-Step, and Maximum\-Integration\-Step. N\-O\-T\-E\-: The valid unit is now limited to only L\-E\-N\-G\-T\-H\-\_\-\-U\-N\-I\-T (1) and C\-E\-L\-L\-\_\-\-L\-E\-N\-G\-T\-H\-\_\-\-U\-N\-I\-T (2), E\-X\-C\-L\-U\-D\-I\-N\-G the previously-\/supported T\-I\-M\-E\-\_\-\-U\-N\-I\-T.  
\item {\ttfamily obj.\-Set\-Integration\-Step\-Unit (int unit)} -\/ Specify a uniform integration step unit for Minimum\-Integration\-Step, Initial\-Integration\-Step, and Maximum\-Integration\-Step. N\-O\-T\-E\-: The valid unit is now limited to only L\-E\-N\-G\-T\-H\-\_\-\-U\-N\-I\-T (1) and C\-E\-L\-L\-\_\-\-L\-E\-N\-G\-T\-H\-\_\-\-U\-N\-I\-T (2), E\-X\-C\-L\-U\-D\-I\-N\-G the previously-\/supported T\-I\-M\-E\-\_\-\-U\-N\-I\-T.  
\item {\ttfamily int = obj.\-Get\-Integration\-Step\-Unit ()} -\/ Specify the Initial step size used for line integration, expressed in\-: L\-E\-N\-G\-T\-H\-\_\-\-U\-N\-I\-T = 1 C\-E\-L\-L\-\_\-\-L\-E\-N\-G\-T\-H\-\_\-\-U\-N\-I\-T = 2 (either the starting size for an adaptive integrator, e.\-g., R\-K45, or the constant / fixed size for non-\/adaptive ones, i.\-e., R\-K2 and R\-K4)  
\item {\ttfamily obj.\-Set\-Initial\-Integration\-Step (double step)} -\/ Specify the Initial step size used for line integration, expressed in\-: L\-E\-N\-G\-T\-H\-\_\-\-U\-N\-I\-T = 1 C\-E\-L\-L\-\_\-\-L\-E\-N\-G\-T\-H\-\_\-\-U\-N\-I\-T = 2 (either the starting size for an adaptive integrator, e.\-g., R\-K45, or the constant / fixed size for non-\/adaptive ones, i.\-e., R\-K2 and R\-K4)  
\item {\ttfamily double = obj.\-Get\-Initial\-Integration\-Step ()} -\/ Specify the Minimum step size used for line integration, expressed in\-: L\-E\-N\-G\-T\-H\-\_\-\-U\-N\-I\-T = 1 C\-E\-L\-L\-\_\-\-L\-E\-N\-G\-T\-H\-\_\-\-U\-N\-I\-T = 2 (Only valid for an adaptive integrator, e.\-g., R\-K45)  
\item {\ttfamily obj.\-Set\-Minimum\-Integration\-Step (double step)} -\/ Specify the Minimum step size used for line integration, expressed in\-: L\-E\-N\-G\-T\-H\-\_\-\-U\-N\-I\-T = 1 C\-E\-L\-L\-\_\-\-L\-E\-N\-G\-T\-H\-\_\-\-U\-N\-I\-T = 2 (Only valid for an adaptive integrator, e.\-g., R\-K45)  
\item {\ttfamily double = obj.\-Get\-Minimum\-Integration\-Step ()} -\/ Specify the Maximum step size used for line integration, expressed in\-: L\-E\-N\-G\-T\-H\-\_\-\-U\-N\-I\-T = 1 C\-E\-L\-L\-\_\-\-L\-E\-N\-G\-T\-H\-\_\-\-U\-N\-I\-T = 2 (Only valid for an adaptive integrator, e.\-g., R\-K45)  
\item {\ttfamily obj.\-Set\-Maximum\-Integration\-Step (double step)} -\/ Specify the Maximum step size used for line integration, expressed in\-: L\-E\-N\-G\-T\-H\-\_\-\-U\-N\-I\-T = 1 C\-E\-L\-L\-\_\-\-L\-E\-N\-G\-T\-H\-\_\-\-U\-N\-I\-T = 2 (Only valid for an adaptive integrator, e.\-g., R\-K45)  
\item {\ttfamily double = obj.\-Get\-Maximum\-Integration\-Step ()}  
\item {\ttfamily obj.\-Set\-Maximum\-Error (double )}  
\item {\ttfamily double = obj.\-Get\-Maximum\-Error ()}  
\item {\ttfamily obj.\-Set\-Maximum\-Number\-Of\-Steps (vtk\-Id\-Type )}  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Maximum\-Number\-Of\-Steps ()}  
\item {\ttfamily obj.\-Set\-Terminal\-Speed (double )}  
\item {\ttfamily double = obj.\-Get\-Terminal\-Speed ()}  
\item {\ttfamily obj.\-Set\-Integration\-Direction (int )} -\/ Specify whether the streamline is integrated in the upstream or downstream direction.  
\item {\ttfamily int = obj.\-Get\-Integration\-Direction\-Min\-Value ()} -\/ Specify whether the streamline is integrated in the upstream or downstream direction.  
\item {\ttfamily int = obj.\-Get\-Integration\-Direction\-Max\-Value ()} -\/ Specify whether the streamline is integrated in the upstream or downstream direction.  
\item {\ttfamily int = obj.\-Get\-Integration\-Direction ()} -\/ Specify whether the streamline is integrated in the upstream or downstream direction.  
\item {\ttfamily obj.\-Set\-Integration\-Direction\-To\-Forward ()} -\/ Specify whether the streamline is integrated in the upstream or downstream direction.  
\item {\ttfamily obj.\-Set\-Integration\-Direction\-To\-Backward ()} -\/ Specify whether the streamline is integrated in the upstream or downstream direction.  
\item {\ttfamily obj.\-Set\-Integration\-Direction\-To\-Both ()} -\/ Specify whether the streamline is integrated in the upstream or downstream direction.  
\item {\ttfamily obj.\-Set\-Compute\-Vorticity (bool )}  
\item {\ttfamily bool = obj.\-Get\-Compute\-Vorticity ()}  
\item {\ttfamily obj.\-Set\-Rotation\-Scale (double )}  
\item {\ttfamily double = obj.\-Get\-Rotation\-Scale ()}  
\item {\ttfamily obj.\-Set\-Interpolator\-Prototype (vtk\-Abstract\-Interpolated\-Velocity\-Field ivf)} -\/ The object used to interpolate the velocity field during integration is of the same class as this prototype.  
\item {\ttfamily obj.\-Set\-Interpolator\-Type (int interp\-Type)} -\/ Set the type of the velocity field interpolator to determine whether vtk\-Interpolated\-Velocity\-Field (I\-N\-T\-E\-R\-P\-O\-L\-A\-T\-O\-R\-\_\-\-W\-I\-T\-H\-\_\-\-D\-A\-T\-A\-S\-E\-T\-\_\-\-P\-O\-I\-N\-T\-\_\-\-L\-O\-C\-A\-T\-O\-R) or vtk\-Cell\-Locator\-Interpolated\-Velocity\-Field (I\-N\-T\-E\-R\-P\-O\-L\-A\-T\-O\-R\-\_\-\-W\-I\-T\-H\-\_\-\-C\-E\-L\-L\-\_\-\-L\-O\-C\-A\-T\-O\-R) is employed for locating cells during streamline integration. The latter (adopting vtk\-Abstract\-Cell\-Locator sub-\/classes such as vtk\-Cell\-Locator and vtk\-Modified\-B\-S\-P\-Tree) is more robust then the former (through vtk\-Data\-Set / vtk\-Point\-Set\-::\-Find\-Cell() coupled with vtk\-Point\-Locator).  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkstripper}{}\section{vtk\-Stripper}\label{vtkgraphics_vtkstripper}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
To create an instance of class vtk\-Stripper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkStripper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Stripper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Stripper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Stripper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Stripper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Maximum\-Length (int )} -\/ Specify the maximum number of triangles in a triangle strip, and/or the maximum number of lines in a poly-\/line.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Length\-Min\-Value ()} -\/ Specify the maximum number of triangles in a triangle strip, and/or the maximum number of lines in a poly-\/line.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Length\-Max\-Value ()} -\/ Specify the maximum number of triangles in a triangle strip, and/or the maximum number of lines in a poly-\/line.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Length ()} -\/ Specify the maximum number of triangles in a triangle strip, and/or the maximum number of lines in a poly-\/line.  
\item {\ttfamily obj.\-Pass\-Cell\-Data\-As\-Field\-Data\-On ()} -\/ Enable/\-Disable passing of the Cell\-Data in the input to the output as Field\-Data. Note the field data is tranformed.  
\item {\ttfamily obj.\-Pass\-Cell\-Data\-As\-Field\-Data\-Off ()} -\/ Enable/\-Disable passing of the Cell\-Data in the input to the output as Field\-Data. Note the field data is tranformed.  
\item {\ttfamily obj.\-Set\-Pass\-Cell\-Data\-As\-Field\-Data (int )} -\/ Enable/\-Disable passing of the Cell\-Data in the input to the output as Field\-Data. Note the field data is tranformed.  
\item {\ttfamily int = obj.\-Get\-Pass\-Cell\-Data\-As\-Field\-Data ()} -\/ Enable/\-Disable passing of the Cell\-Data in the input to the output as Field\-Data. Note the field data is tranformed.  
\item {\ttfamily obj.\-Set\-Pass\-Through\-Cell\-Ids (int )} -\/ If on, the output polygonal dataset will have a celldata array that holds the cell index of the original 3\-D cell that produced each output cell. This is useful for picking. The default is off to conserve memory.  
\item {\ttfamily int = obj.\-Get\-Pass\-Through\-Cell\-Ids ()} -\/ If on, the output polygonal dataset will have a celldata array that holds the cell index of the original 3\-D cell that produced each output cell. This is useful for picking. The default is off to conserve memory.  
\item {\ttfamily obj.\-Pass\-Through\-Cell\-Ids\-On ()} -\/ If on, the output polygonal dataset will have a celldata array that holds the cell index of the original 3\-D cell that produced each output cell. This is useful for picking. The default is off to conserve memory.  
\item {\ttfamily obj.\-Pass\-Through\-Cell\-Ids\-Off ()} -\/ If on, the output polygonal dataset will have a celldata array that holds the cell index of the original 3\-D cell that produced each output cell. This is useful for picking. The default is off to conserve memory.  
\item {\ttfamily obj.\-Set\-Pass\-Through\-Point\-Ids (int )} -\/ If on, the output polygonal dataset will have a pointdata array that holds the point index of the original vertex that produced each output vertex. This is useful for picking. The default is off to conserve memory.  
\item {\ttfamily int = obj.\-Get\-Pass\-Through\-Point\-Ids ()} -\/ If on, the output polygonal dataset will have a pointdata array that holds the point index of the original vertex that produced each output vertex. This is useful for picking. The default is off to conserve memory.  
\item {\ttfamily obj.\-Pass\-Through\-Point\-Ids\-On ()} -\/ If on, the output polygonal dataset will have a pointdata array that holds the point index of the original vertex that produced each output vertex. This is useful for picking. The default is off to conserve memory.  
\item {\ttfamily obj.\-Pass\-Through\-Point\-Ids\-Off ()} -\/ If on, the output polygonal dataset will have a pointdata array that holds the point index of the original vertex that produced each output vertex. This is useful for picking. The default is off to conserve memory.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkstructuredgridclip}{}\section{vtk\-Structured\-Grid\-Clip}\label{vtkgraphics_vtkstructuredgridclip}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Structured\-Grid\-Clip will make an image smaller. The output must have an image extent which is the subset of the input. The filter has two modes of operation\-: 1\-: By default, the data is not copied in this filter. Only the whole extent is modified. 2\-: If Clip\-Data\-On is set, then you will get no more that the clipped extent.

To create an instance of class vtk\-Structured\-Grid\-Clip, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkStructuredGridClip
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Structured\-Grid\-Clip has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Clip class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Structured\-Grid\-Clip = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Structured\-Grid\-Clip = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Output\-Whole\-Extent (int extent\mbox{[}6\mbox{]}, vtk\-Information out\-Info)} -\/ The whole extent of the output has to be set explicitly.  
\item {\ttfamily obj.\-Set\-Output\-Whole\-Extent (int min\-X, int max\-X, int min\-Y, int max\-Y, int min\-Z, int max\-Z)} -\/ The whole extent of the output has to be set explicitly.  
\item {\ttfamily obj.\-Get\-Output\-Whole\-Extent (int extent\mbox{[}6\mbox{]})} -\/ The whole extent of the output has to be set explicitly.  
\item {\ttfamily obj.\-Reset\-Output\-Whole\-Extent ()}  
\item {\ttfamily obj.\-Set\-Clip\-Data (int )} -\/ By default, Clip\-Data is off, and only the Whole\-Extent is modified. the data's extent may actually be larger. When this flag is on, the data extent will be no more than the Output\-Whole\-Extent.  
\item {\ttfamily int = obj.\-Get\-Clip\-Data ()} -\/ By default, Clip\-Data is off, and only the Whole\-Extent is modified. the data's extent may actually be larger. When this flag is on, the data extent will be no more than the Output\-Whole\-Extent.  
\item {\ttfamily obj.\-Clip\-Data\-On ()} -\/ By default, Clip\-Data is off, and only the Whole\-Extent is modified. the data's extent may actually be larger. When this flag is on, the data extent will be no more than the Output\-Whole\-Extent.  
\item {\ttfamily obj.\-Clip\-Data\-Off ()} -\/ By default, Clip\-Data is off, and only the Whole\-Extent is modified. the data's extent may actually be larger. When this flag is on, the data extent will be no more than the Output\-Whole\-Extent.  
\item {\ttfamily obj.\-Set\-Output\-Whole\-Extent (int piece, int num\-Pieces)} -\/ Hack set output by piece  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkstructuredgridgeometryfilter}{}\section{vtk\-Structured\-Grid\-Geometry\-Filter}\label{vtkgraphics_vtkstructuredgridgeometryfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Structured\-Grid\-Geometry\-Filter is a filter that extracts geometry from a structured grid. By specifying appropriate i-\/j-\/k indices, it is possible to extract a point, a curve, a surface, or a \char`\"{}volume\char`\"{}. Depending upon the type of data, the curve and surface may be curved or planar. (The volume is actually a (n x m x o) region of points.)

The extent specification is zero-\/offset. That is, the first k-\/plane in a 50x50x50 structured grid is given by (0,49, 0,49, 0,0).

The output of this filter is affected by the structured grid blanking. If blanking is on, and a blanking array defined, then those cells attached to blanked points are not output. (Blanking is a property of the input vtk\-Structured\-Grid.)

To create an instance of class vtk\-Structured\-Grid\-Geometry\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkStructuredGridGeometryFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Structured\-Grid\-Geometry\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Geometry\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Structured\-Grid\-Geometry\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Structured\-Grid\-Geometry\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj. Get\-Extent ()} -\/ Get the extent in topological coordinate range (imin,imax, jmin,jmax, kmin,kmax).  
\item {\ttfamily obj.\-Set\-Extent (int i\-Min, int i\-Max, int j\-Min, int j\-Max, int k\-Min, int k\-Max)} -\/ Specify (imin,imax, jmin,jmax, kmin,kmax) indices.  
\item {\ttfamily obj.\-Set\-Extent (int extent\mbox{[}6\mbox{]})} -\/ Specify (imin,imax, jmin,jmax, kmin,kmax) indices in array form.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkstructuredgridoutlinefilter}{}\section{vtk\-Structured\-Grid\-Outline\-Filter}\label{vtkgraphics_vtkstructuredgridoutlinefilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Structured\-Grid\-Outline\-Filter is a filter that generates a wireframe outline of a structured grid (vtk\-Structured\-Grid). Structured data is topologically a cube, so the outline will have 12 \char`\"{}edges\char`\"{}.

To create an instance of class vtk\-Structured\-Grid\-Outline\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkStructuredGridOutlineFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Structured\-Grid\-Outline\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Outline\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Structured\-Grid\-Outline\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Structured\-Grid\-Outline\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkstructuredpointsgeometryfilter}{}\section{vtk\-Structured\-Points\-Geometry\-Filter}\label{vtkgraphics_vtkstructuredpointsgeometryfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Structured\-Points\-Geometry\-Filter has been renamed to vtk\-Image\-Data\-Geometry\-Filter

To create an instance of class vtk\-Structured\-Points\-Geometry\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkStructuredPointsGeometryFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Structured\-Points\-Geometry\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Geometry\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Structured\-Points\-Geometry\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Structured\-Points\-Geometry\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtksubdividetetra}{}\section{vtk\-Subdivide\-Tetra}\label{vtkgraphics_vtksubdividetetra}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This filter subdivides tetrahedra in an unstructured grid into twelve tetrahedra.

To create an instance of class vtk\-Subdivide\-Tetra, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSubdivideTetra
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Subdivide\-Tetra has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Subdivide\-Tetra class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Subdivide\-Tetra = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Subdivide\-Tetra = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtksubpixelpositionedgels}{}\section{vtk\-Sub\-Pixel\-Position\-Edgels}\label{vtkgraphics_vtksubpixelpositionedgels}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Sub\-Pixel\-Position\-Edgels is a filter that takes a series of linked edgels (digital curves) and gradient maps as input. It then adjusts the edgel locations based on the gradient data. Specifically, the algorithm first determines the neighboring gradient magnitudes of an edgel using simple interpolation of its neighbors. It then fits the following three data points\-: negative gradient direction gradient magnitude, edgel gradient magnitude and positive gradient direction gradient magnitude to a quadratic function. It then solves this quadratic to find the maximum gradient location along the gradient orientation. It then modifies the edgels location along the gradient orientation to the calculated maximum location. This algorithm does not adjust an edgel in the direction orthogonal to its gradient vector.

To create an instance of class vtk\-Sub\-Pixel\-Position\-Edgels, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSubPixelPositionEdgels
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Sub\-Pixel\-Position\-Edgels has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Sub\-Pixel\-Position\-Edgels class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Sub\-Pixel\-Position\-Edgels = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Sub\-Pixel\-Position\-Edgels = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Grad\-Maps (vtk\-Structured\-Points gm)} -\/ Set/\-Get the gradient data for doing the position adjustments.  
\item {\ttfamily vtk\-Structured\-Points = obj.\-Get\-Grad\-Maps ()} -\/ Set/\-Get the gradient data for doing the position adjustments.  
\item {\ttfamily obj.\-Set\-Target\-Flag (int )} -\/ These methods can make the positioning look for a target scalar value instead of looking for a maximum.  
\item {\ttfamily int = obj.\-Get\-Target\-Flag ()} -\/ These methods can make the positioning look for a target scalar value instead of looking for a maximum.  
\item {\ttfamily obj.\-Target\-Flag\-On ()} -\/ These methods can make the positioning look for a target scalar value instead of looking for a maximum.  
\item {\ttfamily obj.\-Target\-Flag\-Off ()} -\/ These methods can make the positioning look for a target scalar value instead of looking for a maximum.  
\item {\ttfamily obj.\-Set\-Target\-Value (double )} -\/ These methods can make the positioning look for a target scalar value instead of looking for a maximum.  
\item {\ttfamily double = obj.\-Get\-Target\-Value ()} -\/ These methods can make the positioning look for a target scalar value instead of looking for a maximum.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtksuperquadricsource}{}\section{vtk\-Superquadric\-Source}\label{vtkgraphics_vtksuperquadricsource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Superquadric\-Source creates a superquadric (represented by polygons) of specified size centered at the origin. The resolution (polygonal discretization) in both the latitude (phi) and longitude (theta) directions can be specified. Roundness parameters (Phi\-Roundness and Theta\-Roundness) control the shape of the superquadric. The Toroidal boolean controls whether a toroidal superquadric is produced. If so, the Thickness parameter controls the thickness of the toroid\-: 0 is the thinnest allowable toroid, and 1 has a minimum sized hole. The Scale parameters allow the superquadric to be scaled in x, y, and z (normal vectors are correctly generated in any case). The Size parameter controls size of the superquadric.

This code is based on \char`\"{}\-Rigid physically based superquadrics\char`\"{}, A. H. Barr, in \char`\"{}\-Graphics Gems I\-I\-I\char`\"{}, David Kirk, ed., Academic Press, 1992.

To create an instance of class vtk\-Superquadric\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSuperquadricSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Superquadric\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Superquadric\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Superquadric\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Superquadric\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Center (double , double , double )} -\/ Set the center of the superquadric. Default is 0,0,0.  
\item {\ttfamily obj.\-Set\-Center (double a\mbox{[}3\mbox{]})} -\/ Set the center of the superquadric. Default is 0,0,0.  
\item {\ttfamily double = obj. Get\-Center ()} -\/ Set the center of the superquadric. Default is 0,0,0.  
\item {\ttfamily obj.\-Set\-Scale (double , double , double )} -\/ Set the scale factors of the superquadric. Default is 1,1,1.  
\item {\ttfamily obj.\-Set\-Scale (double a\mbox{[}3\mbox{]})} -\/ Set the scale factors of the superquadric. Default is 1,1,1.  
\item {\ttfamily double = obj. Get\-Scale ()} -\/ Set the scale factors of the superquadric. Default is 1,1,1.  
\item {\ttfamily int = obj.\-Get\-Theta\-Resolution ()} -\/ Set the number of points in the longitude direction. Initial value is 16.  
\item {\ttfamily obj.\-Set\-Theta\-Resolution (int i)} -\/ Set the number of points in the longitude direction. Initial value is 16.  
\item {\ttfamily int = obj.\-Get\-Phi\-Resolution ()} -\/ Set the number of points in the latitude direction. Initial value is 16.  
\item {\ttfamily obj.\-Set\-Phi\-Resolution (int i)} -\/ Set the number of points in the latitude direction. Initial value is 16.  
\item {\ttfamily double = obj.\-Get\-Thickness ()} -\/ Set/\-Get Superquadric ring thickness (toroids only). Changing thickness maintains the outside diameter of the toroid. Initial value is 0.\-3333.  
\item {\ttfamily obj.\-Set\-Thickness (double )} -\/ Set/\-Get Superquadric ring thickness (toroids only). Changing thickness maintains the outside diameter of the toroid. Initial value is 0.\-3333.  
\item {\ttfamily double = obj.\-Get\-Thickness\-Min\-Value ()} -\/ Set/\-Get Superquadric ring thickness (toroids only). Changing thickness maintains the outside diameter of the toroid. Initial value is 0.\-3333.  
\item {\ttfamily double = obj.\-Get\-Thickness\-Max\-Value ()} -\/ Set/\-Get Superquadric ring thickness (toroids only). Changing thickness maintains the outside diameter of the toroid. Initial value is 0.\-3333.  
\item {\ttfamily double = obj.\-Get\-Phi\-Roundness ()} -\/ Set/\-Get Superquadric north/south roundness. Values range from 0 (rectangular) to 1 (circular) to higher orders. Initial value is 1.\-0.  
\item {\ttfamily obj.\-Set\-Phi\-Roundness (double e)} -\/ Set/\-Get Superquadric north/south roundness. Values range from 0 (rectangular) to 1 (circular) to higher orders. Initial value is 1.\-0.  
\item {\ttfamily double = obj.\-Get\-Theta\-Roundness ()} -\/ Set/\-Get Superquadric east/west roundness. Values range from 0 (rectangular) to 1 (circular) to higher orders. Initial value is 1.\-0.  
\item {\ttfamily obj.\-Set\-Theta\-Roundness (double e)} -\/ Set/\-Get Superquadric east/west roundness. Values range from 0 (rectangular) to 1 (circular) to higher orders. Initial value is 1.\-0.  
\item {\ttfamily obj.\-Set\-Size (double )} -\/ Set/\-Get Superquadric isotropic size. Initial value is 0.\-5;  
\item {\ttfamily double = obj.\-Get\-Size ()} -\/ Set/\-Get Superquadric isotropic size. Initial value is 0.\-5;  
\item {\ttfamily obj.\-Toroidal\-On ()} -\/ Set/\-Get whether or not the superquadric is toroidal (1) or ellipsoidal (0). Initial value is 0.  
\item {\ttfamily obj.\-Toroidal\-Off ()} -\/ Set/\-Get whether or not the superquadric is toroidal (1) or ellipsoidal (0). Initial value is 0.  
\item {\ttfamily int = obj.\-Get\-Toroidal ()} -\/ Set/\-Get whether or not the superquadric is toroidal (1) or ellipsoidal (0). Initial value is 0.  
\item {\ttfamily obj.\-Set\-Toroidal (int )} -\/ Set/\-Get whether or not the superquadric is toroidal (1) or ellipsoidal (0). Initial value is 0.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtksynchronizedtemplates2d}{}\section{vtk\-Synchronized\-Templates2\-D}\label{vtkgraphics_vtksynchronizedtemplates2d}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Synchronized\-Templates2\-D is a 2\-D implementation of the synchronized template algorithm. Note that vtk\-Contour\-Filter will automatically use this class when appropriate.

To create an instance of class vtk\-Synchronized\-Templates2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSynchronizedTemplates2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Synchronized\-Templates2\-D has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Synchronized\-Templates2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Synchronized\-Templates2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Synchronized\-Templates2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Because we delegate to vtk\-Contour\-Values  
\item {\ttfamily obj.\-Set\-Value (int i, double value)} -\/ Get the ith contour value.  
\item {\ttfamily double = obj.\-Get\-Value (int i)} -\/ Get a pointer to an array of contour values. There will be Get\-Number\-Of\-Contours() values in the list.  
\item {\ttfamily obj.\-Get\-Values (double contour\-Values)} -\/ Set the number of contours to place into the list. You only really need to use this method to reduce list size. The method Set\-Value() will automatically increase list size as needed.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Contours (int number)} -\/ Get the number of contours in the list of contour values.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Contours ()} -\/ Generate num\-Contours equally spaced contour values between specified range. Contour values will include min/max range values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\mbox{[}2\mbox{]})} -\/ Generate num\-Contours equally spaced contour values between specified range. Contour values will include min/max range values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\-Start, double range\-End)} -\/ Option to set the point scalars of the output. The scalars will be the iso value of course. By default this flag is on.  
\item {\ttfamily obj.\-Set\-Compute\-Scalars (int )} -\/ Option to set the point scalars of the output. The scalars will be the iso value of course. By default this flag is on.  
\item {\ttfamily int = obj.\-Get\-Compute\-Scalars ()} -\/ Option to set the point scalars of the output. The scalars will be the iso value of course. By default this flag is on.  
\item {\ttfamily obj.\-Compute\-Scalars\-On ()} -\/ Option to set the point scalars of the output. The scalars will be the iso value of course. By default this flag is on.  
\item {\ttfamily obj.\-Compute\-Scalars\-Off ()} -\/ Option to set the point scalars of the output. The scalars will be the iso value of course. By default this flag is on.  
\item {\ttfamily obj.\-Set\-Array\-Component (int )} -\/ Set/get which component of the scalar array to contour on; defaults to 0.  
\item {\ttfamily int = obj.\-Get\-Array\-Component ()} -\/ Set/get which component of the scalar array to contour on; defaults to 0.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtksynchronizedtemplates3d}{}\section{vtk\-Synchronized\-Templates3\-D}\label{vtkgraphics_vtksynchronizedtemplates3d}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Synchronized\-Templates3\-D is a 3\-D implementation of the synchronized template algorithm. Note that vtk\-Contour\-Filter will automatically use this class when appropriate.

To create an instance of class vtk\-Synchronized\-Templates3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSynchronizedTemplates3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Synchronized\-Templates3\-D has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Synchronized\-Templates3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Synchronized\-Templates3\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Synchronized\-Templates3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Because we delegate to vtk\-Contour\-Values  
\item {\ttfamily obj.\-Set\-Compute\-Normals (int )} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily int = obj.\-Get\-Compute\-Normals ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Normals\-On ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Normals\-Off ()} -\/ Set/\-Get the computation of normals. Normal computation is fairly expensive in both time and storage. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Set\-Compute\-Gradients (int )} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily int = obj.\-Get\-Compute\-Gradients ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Gradients\-On ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Compute\-Gradients\-Off ()} -\/ Set/\-Get the computation of gradients. Gradient computation is fairly expensive in both time and storage. Note that if Compute\-Normals is on, gradients will have to be calculated, but will not be stored in the output dataset. If the output data will be processed by filters that modify topology or geometry, it may be wise to turn Normals and Gradients off.  
\item {\ttfamily obj.\-Set\-Compute\-Scalars (int )} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily int = obj.\-Get\-Compute\-Scalars ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Compute\-Scalars\-On ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Compute\-Scalars\-Off ()} -\/ Set/\-Get the computation of scalars.  
\item {\ttfamily obj.\-Set\-Value (int i, double value)} -\/ Get the ith contour value.  
\item {\ttfamily double = obj.\-Get\-Value (int i)} -\/ Get a pointer to an array of contour values. There will be Get\-Number\-Of\-Contours() values in the list.  
\item {\ttfamily obj.\-Get\-Values (double contour\-Values)} -\/ Set the number of contours to place into the list. You only really need to use this method to reduce list size. The method Set\-Value() will automatically increase list size as needed.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Contours (int number)} -\/ Get the number of contours in the list of contour values.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Contours ()} -\/ Generate num\-Contours equally spaced contour values between specified range. Contour values will include min/max range values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\mbox{[}2\mbox{]})} -\/ Generate num\-Contours equally spaced contour values between specified range. Contour values will include min/max range values.  
\item {\ttfamily obj.\-Generate\-Values (int num\-Contours, double range\-Start, double range\-End)} -\/ Needed by templated functions.  
\item {\ttfamily int = obj.\-Get\-Execute\-Extent ()} -\/ Needed by templated functions.  
\item {\ttfamily obj.\-Threaded\-Execute (vtk\-Image\-Data data, vtk\-Information in\-Info, vtk\-Information out\-Info, int ex\-Ext, vtk\-Data\-Array in\-Scalars)} -\/ Needed by templated functions.  
\item {\ttfamily obj.\-Set\-Input\-Memory\-Limit (long limit)} -\/ Determines the chunk size fro streaming. This filter will act like a collector\-: ask for many input pieces, but generate one output. Limit is in K\-Bytes  
\item {\ttfamily long = obj.\-Get\-Input\-Memory\-Limit ()} -\/ Determines the chunk size fro streaming. This filter will act like a collector\-: ask for many input pieces, but generate one output. Limit is in K\-Bytes  
\item {\ttfamily obj.\-Set\-Array\-Component (int )} -\/ Set/get which component of the scalar array to contour on; defaults to 0.  
\item {\ttfamily int = obj.\-Get\-Array\-Component ()} -\/ Set/get which component of the scalar array to contour on; defaults to 0.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtksynchronizedtemplatescutter3d}{}\section{vtk\-Synchronized\-Templates\-Cutter3\-D}\label{vtkgraphics_vtksynchronizedtemplatescutter3d}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Synchronized\-Templates\-Cutter3\-D is an implementation of the synchronized template algorithm. Note that vtk\-Cut\-Filter will automatically use this class when appropriate.

To create an instance of class vtk\-Synchronized\-Templates\-Cutter3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSynchronizedTemplatesCutter3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Synchronized\-Templates\-Cutter3\-D has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Synchronized\-Templates\-Cutter3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Synchronized\-Templates\-Cutter3\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Synchronized\-Templates\-Cutter3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Threaded\-Execute (vtk\-Image\-Data data, vtk\-Information out\-Info, int ex\-Ext, int )} -\/ Needed by templated functions.  
\item {\ttfamily obj.\-Set\-Cut\-Function (vtk\-Implicit\-Function )}  
\item {\ttfamily vtk\-Implicit\-Function = obj.\-Get\-Cut\-Function ()}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtktablebasedclipdataset}{}\section{vtk\-Table\-Based\-Clip\-Data\-Set}\label{vtkgraphics_vtktablebasedclipdataset}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Table\-Based\-Clip\-Data\-Set is a filter that clips any type of dataset using either any subclass of vtk\-Implicit\-Function or an input scalar point data array. Clipping means that it actually \char`\"{}cuts\char`\"{} through the cells of the dataset, returning everything outside the specified implicit function (or greater than the scalar value) including \char`\"{}pieces\char`\"{} of a cell (Note to compare this with vtk\-Extract\-Geometry, which pulls out entire, uncut cells). The output of this filter is a vtk\-Unstructured\-Grid data.

To use this filter, you need to decide whether an implicit function or an input scalar point data array is used for clipping. For the former case, 1) define an implicit function 2) provide it to this filter via Set\-Clip\-Function() If a clipping function is not specified, or Generate\-Clip\-Scalars is off( the default), the input scalar point data array is then employed for clipping.

You can also specify a scalar (iso-\/)value, which is used to decide what is inside and outside the implicit function. You can also reverse the sense of what inside/outside is by setting I\-V\-A\-R Inside\-Out. The clipping algorithm proceeds by computing an implicit function value or using the input scalar point data value for each point in the dataset. This is compared against the scalar (iso-\/)value to determine the inside/outside status.

Although this filter sometimes (but rarely) may resort to the sibling class vtk\-Clip\-Data\-Set for handling some special grids (such as cylinders or cones with capping faces in the form of a vtk\-Poly\-Data), it itself is able to deal with most grids. It is worth mentioning that vtk\-Table\-Based\-Clip\-Data\-Set is capable of addressing the artifacts that may occur with vtk\-Clip\-Data\-Set due to the possibly inconsistent triagulation modes between neighboring cells. In addition, the former is much faster than the latter. Furthermore, the former produces less cells (with ratio usually being 5$\sim$6) than by the latter in the output. In other words, this filter retains the original cells (i.\-e., without triangulation / tetrahedralization) wherever possible. All these advantages are gained by adopting the unique clipping and triangulation tables proposed by Vis\-It.

To create an instance of class vtk\-Table\-Based\-Clip\-Data\-Set, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTableBasedClipDataSet
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Table\-Based\-Clip\-Data\-Set has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Table\-Based\-Clip\-Data\-Set class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Table\-Based\-Clip\-Data\-Set = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Table\-Based\-Clip\-Data\-Set = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Get the M\-Time for which the point locator and clip function are consdiered.  
\item {\ttfamily obj.\-Set\-Inside\-Out (int )} -\/ Set/\-Get the Inside\-Out flag. With this flag off, a vertex is considered inside (the implicit function or the isosurface) if the (function or scalar) value is greater than I\-V\-A\-R Value. With this flag on, a vertex is considered inside (the implicit function or the isosurface) if the (function or scalar) value is less than or equal to I\-V\-A\-R Value. This flag is off by default.  
\item {\ttfamily int = obj.\-Get\-Inside\-Out ()} -\/ Set/\-Get the Inside\-Out flag. With this flag off, a vertex is considered inside (the implicit function or the isosurface) if the (function or scalar) value is greater than I\-V\-A\-R Value. With this flag on, a vertex is considered inside (the implicit function or the isosurface) if the (function or scalar) value is less than or equal to I\-V\-A\-R Value. This flag is off by default.  
\item {\ttfamily obj.\-Inside\-Out\-On ()} -\/ Set/\-Get the Inside\-Out flag. With this flag off, a vertex is considered inside (the implicit function or the isosurface) if the (function or scalar) value is greater than I\-V\-A\-R Value. With this flag on, a vertex is considered inside (the implicit function or the isosurface) if the (function or scalar) value is less than or equal to I\-V\-A\-R Value. This flag is off by default.  
\item {\ttfamily obj.\-Inside\-Out\-Off ()} -\/ Set/\-Get the Inside\-Out flag. With this flag off, a vertex is considered inside (the implicit function or the isosurface) if the (function or scalar) value is greater than I\-V\-A\-R Value. With this flag on, a vertex is considered inside (the implicit function or the isosurface) if the (function or scalar) value is less than or equal to I\-V\-A\-R Value. This flag is off by default.  
\item {\ttfamily obj.\-Set\-Value (double )} -\/ Set/\-Get the clipping value of the implicit function (if an implicit function is applied) or scalar data array (if a scalar data array is used), with 0.\-0 as the default value. This value is ignored if flag Use\-Value\-As\-Offset is true A\-N\-D a clip function is defined.  
\item {\ttfamily double = obj.\-Get\-Value ()} -\/ Set/\-Get the clipping value of the implicit function (if an implicit function is applied) or scalar data array (if a scalar data array is used), with 0.\-0 as the default value. This value is ignored if flag Use\-Value\-As\-Offset is true A\-N\-D a clip function is defined.  
\item {\ttfamily obj.\-Set\-Use\-Value\-As\-Offset (bool )} -\/ Set/\-Get flag Use\-Value\-As\-Offset, with true as the default value. With this flag on, I\-V\-A\-R Value is used as an offset parameter to the implicit function. Value is used only when clipping using a scalar array.  
\item {\ttfamily bool = obj.\-Get\-Use\-Value\-As\-Offset ()} -\/ Set/\-Get flag Use\-Value\-As\-Offset, with true as the default value. With this flag on, I\-V\-A\-R Value is used as an offset parameter to the implicit function. Value is used only when clipping using a scalar array.  
\item {\ttfamily obj.\-Use\-Value\-As\-Offset\-On ()} -\/ Set/\-Get flag Use\-Value\-As\-Offset, with true as the default value. With this flag on, I\-V\-A\-R Value is used as an offset parameter to the implicit function. Value is used only when clipping using a scalar array.  
\item {\ttfamily obj.\-Use\-Value\-As\-Offset\-Off ()} -\/ Set/\-Get flag Use\-Value\-As\-Offset, with true as the default value. With this flag on, I\-V\-A\-R Value is used as an offset parameter to the implicit function. Value is used only when clipping using a scalar array.  
\item {\ttfamily obj.\-Set\-Clip\-Function (vtk\-Implicit\-Function )}  
\item {\ttfamily vtk\-Implicit\-Function = obj.\-Get\-Clip\-Function ()}  
\item {\ttfamily obj.\-Set\-Generate\-Clip\-Scalars (int )} -\/ Set/\-Get flag Generate\-Clip\-Scalars, with 0 as the default value. With this flag on, the scalar point data values obtained by evaluating the implicit function will be exported to the output. Note that this flag requries that an implicit function be provided.  
\item {\ttfamily int = obj.\-Get\-Generate\-Clip\-Scalars ()} -\/ Set/\-Get flag Generate\-Clip\-Scalars, with 0 as the default value. With this flag on, the scalar point data values obtained by evaluating the implicit function will be exported to the output. Note that this flag requries that an implicit function be provided.  
\item {\ttfamily obj.\-Generate\-Clip\-Scalars\-On ()} -\/ Set/\-Get flag Generate\-Clip\-Scalars, with 0 as the default value. With this flag on, the scalar point data values obtained by evaluating the implicit function will be exported to the output. Note that this flag requries that an implicit function be provided.  
\item {\ttfamily obj.\-Generate\-Clip\-Scalars\-Off ()} -\/ Set/\-Get flag Generate\-Clip\-Scalars, with 0 as the default value. With this flag on, the scalar point data values obtained by evaluating the implicit function will be exported to the output. Note that this flag requries that an implicit function be provided.  
\item {\ttfamily obj.\-Set\-Locator (vtk\-Incremental\-Point\-Locator locator)} -\/ Set/\-Get a point locator locator for merging duplicate points. By default, an instance of vtk\-Merge\-Points is used. Note that this I\-V\-A\-R is provided in this class only because this filter may resort to its sibling class vtk\-Clip\-Data\-Set when processing some special grids (such as cylinders or cones with capping faces in the form of a vtk\-Poly\-Data) while the latter requires a point locator. This filter itself does not need a locator.  
\item {\ttfamily vtk\-Incremental\-Point\-Locator = obj.\-Get\-Locator ()} -\/ Set/\-Get a point locator locator for merging duplicate points. By default, an instance of vtk\-Merge\-Points is used. Note that this I\-V\-A\-R is provided in this class only because this filter may resort to its sibling class vtk\-Clip\-Data\-Set when processing some special grids (such as cylinders or cones with capping faces in the form of a vtk\-Poly\-Data) while the latter requires a point locator. This filter itself does not need a locator.  
\item {\ttfamily obj.\-Set\-Merge\-Tolerance (double )} -\/ Set/\-Get the tolerance used for merging duplicate points near the clipping intersection cells. This tolerance may prevent the generation of degenerate primitives. Note that only 3\-D cells actually use this I\-V\-A\-R.  
\item {\ttfamily double = obj.\-Get\-Merge\-Tolerance\-Min\-Value ()} -\/ Set/\-Get the tolerance used for merging duplicate points near the clipping intersection cells. This tolerance may prevent the generation of degenerate primitives. Note that only 3\-D cells actually use this I\-V\-A\-R.  
\item {\ttfamily double = obj.\-Get\-Merge\-Tolerance\-Max\-Value ()} -\/ Set/\-Get the tolerance used for merging duplicate points near the clipping intersection cells. This tolerance may prevent the generation of degenerate primitives. Note that only 3\-D cells actually use this I\-V\-A\-R.  
\item {\ttfamily double = obj.\-Get\-Merge\-Tolerance ()} -\/ Set/\-Get the tolerance used for merging duplicate points near the clipping intersection cells. This tolerance may prevent the generation of degenerate primitives. Note that only 3\-D cells actually use this I\-V\-A\-R.  
\item {\ttfamily obj.\-Create\-Default\-Locator ()} -\/ Create a default point locator when none is specified. The point locator is used to merge coincident points.  
\item {\ttfamily obj.\-Set\-Generate\-Clipped\-Output (int )} -\/ Set/\-Get whether a second output is generated. The second output contains the polygonal data that is clipped away by the iso-\/surface.  
\item {\ttfamily int = obj.\-Get\-Generate\-Clipped\-Output ()} -\/ Set/\-Get whether a second output is generated. The second output contains the polygonal data that is clipped away by the iso-\/surface.  
\item {\ttfamily obj.\-Generate\-Clipped\-Output\-On ()} -\/ Set/\-Get whether a second output is generated. The second output contains the polygonal data that is clipped away by the iso-\/surface.  
\item {\ttfamily obj.\-Generate\-Clipped\-Output\-Off ()} -\/ Set/\-Get whether a second output is generated. The second output contains the polygonal data that is clipped away by the iso-\/surface.  
\item {\ttfamily vtk\-Unstructured\-Grid = obj.\-Get\-Clipped\-Output ()} -\/ Return the clipped output.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtktabletopolydata}{}\section{vtk\-Table\-To\-Poly\-Data}\label{vtkgraphics_vtktabletopolydata}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Table\-To\-Poly\-Data is a filter used to convert a vtk\-Table to a vtk\-Poly\-Data consisting of vertices.

To create an instance of class vtk\-Table\-To\-Poly\-Data, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTableToPolyData
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Table\-To\-Poly\-Data has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Table\-To\-Poly\-Data class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Table\-To\-Poly\-Data = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Table\-To\-Poly\-Data = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-X\-Column (string )} -\/ Set the name of the column to use as the X coordinate for the points.  
\item {\ttfamily string = obj.\-Get\-X\-Column ()} -\/ Set the name of the column to use as the X coordinate for the points.  
\item {\ttfamily obj.\-Set\-X\-Column\-Index (int )} -\/ Set the index of the column to use as the X coordinate for the points.  
\item {\ttfamily int = obj.\-Get\-X\-Column\-Index\-Min\-Value ()} -\/ Set the index of the column to use as the X coordinate for the points.  
\item {\ttfamily int = obj.\-Get\-X\-Column\-Index\-Max\-Value ()} -\/ Set the index of the column to use as the X coordinate for the points.  
\item {\ttfamily int = obj.\-Get\-X\-Column\-Index ()} -\/ Set the index of the column to use as the X coordinate for the points.  
\item {\ttfamily obj.\-Set\-X\-Component (int )} -\/ Specify the component for the column specified using Set\-X\-Column() to use as the xcoordinate in case the column is a multi-\/component array. Default is 0.  
\item {\ttfamily int = obj.\-Get\-X\-Component\-Min\-Value ()} -\/ Specify the component for the column specified using Set\-X\-Column() to use as the xcoordinate in case the column is a multi-\/component array. Default is 0.  
\item {\ttfamily int = obj.\-Get\-X\-Component\-Max\-Value ()} -\/ Specify the component for the column specified using Set\-X\-Column() to use as the xcoordinate in case the column is a multi-\/component array. Default is 0.  
\item {\ttfamily int = obj.\-Get\-X\-Component ()} -\/ Specify the component for the column specified using Set\-X\-Column() to use as the xcoordinate in case the column is a multi-\/component array. Default is 0.  
\item {\ttfamily obj.\-Set\-Y\-Column (string )} -\/ Set the name of the column to use as the Y coordinate for the points. Default is 0.  
\item {\ttfamily string = obj.\-Get\-Y\-Column ()} -\/ Set the name of the column to use as the Y coordinate for the points. Default is 0.  
\item {\ttfamily obj.\-Set\-Y\-Column\-Index (int )} -\/ Set the index of the column to use as the Y coordinate for the points.  
\item {\ttfamily int = obj.\-Get\-Y\-Column\-Index\-Min\-Value ()} -\/ Set the index of the column to use as the Y coordinate for the points.  
\item {\ttfamily int = obj.\-Get\-Y\-Column\-Index\-Max\-Value ()} -\/ Set the index of the column to use as the Y coordinate for the points.  
\item {\ttfamily int = obj.\-Get\-Y\-Column\-Index ()} -\/ Set the index of the column to use as the Y coordinate for the points.  
\item {\ttfamily obj.\-Set\-Y\-Component (int )} -\/ Specify the component for the column specified using Set\-Y\-Column() to use as the Ycoordinate in case the column is a multi-\/component array.  
\item {\ttfamily int = obj.\-Get\-Y\-Component\-Min\-Value ()} -\/ Specify the component for the column specified using Set\-Y\-Column() to use as the Ycoordinate in case the column is a multi-\/component array.  
\item {\ttfamily int = obj.\-Get\-Y\-Component\-Max\-Value ()} -\/ Specify the component for the column specified using Set\-Y\-Column() to use as the Ycoordinate in case the column is a multi-\/component array.  
\item {\ttfamily int = obj.\-Get\-Y\-Component ()} -\/ Specify the component for the column specified using Set\-Y\-Column() to use as the Ycoordinate in case the column is a multi-\/component array.  
\item {\ttfamily obj.\-Set\-Z\-Column (string )} -\/ Set the name of the column to use as the Z coordinate for the points. Default is 0.  
\item {\ttfamily string = obj.\-Get\-Z\-Column ()} -\/ Set the name of the column to use as the Z coordinate for the points. Default is 0.  
\item {\ttfamily obj.\-Set\-Z\-Column\-Index (int )} -\/ Set the index of the column to use as the Z coordinate for the points.  
\item {\ttfamily int = obj.\-Get\-Z\-Column\-Index\-Min\-Value ()} -\/ Set the index of the column to use as the Z coordinate for the points.  
\item {\ttfamily int = obj.\-Get\-Z\-Column\-Index\-Max\-Value ()} -\/ Set the index of the column to use as the Z coordinate for the points.  
\item {\ttfamily int = obj.\-Get\-Z\-Column\-Index ()} -\/ Set the index of the column to use as the Z coordinate for the points.  
\item {\ttfamily obj.\-Set\-Z\-Component (int )} -\/ Specify the component for the column specified using Set\-Z\-Column() to use as the Zcoordinate in case the column is a multi-\/component array.  
\item {\ttfamily int = obj.\-Get\-Z\-Component\-Min\-Value ()} -\/ Specify the component for the column specified using Set\-Z\-Column() to use as the Zcoordinate in case the column is a multi-\/component array.  
\item {\ttfamily int = obj.\-Get\-Z\-Component\-Max\-Value ()} -\/ Specify the component for the column specified using Set\-Z\-Column() to use as the Zcoordinate in case the column is a multi-\/component array.  
\item {\ttfamily int = obj.\-Get\-Z\-Component ()} -\/ Specify the component for the column specified using Set\-Z\-Column() to use as the Zcoordinate in case the column is a multi-\/component array.  
\item {\ttfamily obj.\-Set\-Create2\-D\-Points (bool )} -\/ Specify whether the points of the polydata are 3\-D or 2\-D. If this is set to true then the Z Column will be ignored and the z value of each point on the polydata will be set to 0. By default this will be off.  
\item {\ttfamily bool = obj.\-Get\-Create2\-D\-Points ()} -\/ Specify whether the points of the polydata are 3\-D or 2\-D. If this is set to true then the Z Column will be ignored and the z value of each point on the polydata will be set to 0. By default this will be off.  
\item {\ttfamily obj.\-Create2\-D\-Points\-On ()} -\/ Specify whether the points of the polydata are 3\-D or 2\-D. If this is set to true then the Z Column will be ignored and the z value of each point on the polydata will be set to 0. By default this will be off.  
\item {\ttfamily obj.\-Create2\-D\-Points\-Off ()} -\/ Specify whether the points of the polydata are 3\-D or 2\-D. If this is set to true then the Z Column will be ignored and the z value of each point on the polydata will be set to 0. By default this will be off.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtktabletostructuredgrid}{}\section{vtk\-Table\-To\-Structured\-Grid}\label{vtkgraphics_vtktabletostructuredgrid}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Table\-To\-Structured\-Grid is a filter that converts an input vtk\-Table to a vtk\-Structured\-Grid. It provides A\-P\-I to select columns to use as points in the output structured grid. The specified dimensions of the output (specified using Set\-Whole\-Extent()) must match the number of rows in the input table.

To create an instance of class vtk\-Table\-To\-Structured\-Grid, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTableToStructuredGrid
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Table\-To\-Structured\-Grid has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-To\-Structured\-Grid class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Table\-To\-Structured\-Grid = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Table\-To\-Structured\-Grid = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Whole\-Extent (int , int , int , int , int , int )} -\/ Get/\-Set the whole extents for the image to produce. The size of the image must match the number of rows in the input table.  
\item {\ttfamily obj.\-Set\-Whole\-Extent (int a\mbox{[}6\mbox{]})} -\/ Get/\-Set the whole extents for the image to produce. The size of the image must match the number of rows in the input table.  
\item {\ttfamily int = obj. Get\-Whole\-Extent ()} -\/ Get/\-Set the whole extents for the image to produce. The size of the image must match the number of rows in the input table.  
\item {\ttfamily obj.\-Set\-X\-Column (string )} -\/ Set the name of the column to use as the X coordinate for the points.  
\item {\ttfamily string = obj.\-Get\-X\-Column ()} -\/ Set the name of the column to use as the X coordinate for the points.  
\item {\ttfamily obj.\-Set\-X\-Component (int )} -\/ Specify the component for the column specified using Set\-X\-Column() to use as the xcoordinate in case the column is a multi-\/component array. Default is 0.  
\item {\ttfamily int = obj.\-Get\-X\-Component\-Min\-Value ()} -\/ Specify the component for the column specified using Set\-X\-Column() to use as the xcoordinate in case the column is a multi-\/component array. Default is 0.  
\item {\ttfamily int = obj.\-Get\-X\-Component\-Max\-Value ()} -\/ Specify the component for the column specified using Set\-X\-Column() to use as the xcoordinate in case the column is a multi-\/component array. Default is 0.  
\item {\ttfamily int = obj.\-Get\-X\-Component ()} -\/ Specify the component for the column specified using Set\-X\-Column() to use as the xcoordinate in case the column is a multi-\/component array. Default is 0.  
\item {\ttfamily obj.\-Set\-Y\-Column (string )} -\/ Set the name of the column to use as the Y coordinate for the points. Default is 0.  
\item {\ttfamily string = obj.\-Get\-Y\-Column ()} -\/ Set the name of the column to use as the Y coordinate for the points. Default is 0.  
\item {\ttfamily obj.\-Set\-Y\-Component (int )} -\/ Specify the component for the column specified using Set\-Y\-Column() to use as the Ycoordinate in case the column is a multi-\/component array.  
\item {\ttfamily int = obj.\-Get\-Y\-Component\-Min\-Value ()} -\/ Specify the component for the column specified using Set\-Y\-Column() to use as the Ycoordinate in case the column is a multi-\/component array.  
\item {\ttfamily int = obj.\-Get\-Y\-Component\-Max\-Value ()} -\/ Specify the component for the column specified using Set\-Y\-Column() to use as the Ycoordinate in case the column is a multi-\/component array.  
\item {\ttfamily int = obj.\-Get\-Y\-Component ()} -\/ Specify the component for the column specified using Set\-Y\-Column() to use as the Ycoordinate in case the column is a multi-\/component array.  
\item {\ttfamily obj.\-Set\-Z\-Column (string )} -\/ Set the name of the column to use as the Z coordinate for the points. Default is 0.  
\item {\ttfamily string = obj.\-Get\-Z\-Column ()} -\/ Set the name of the column to use as the Z coordinate for the points. Default is 0.  
\item {\ttfamily obj.\-Set\-Z\-Component (int )} -\/ Specify the component for the column specified using Set\-Z\-Column() to use as the Zcoordinate in case the column is a multi-\/component array.  
\item {\ttfamily int = obj.\-Get\-Z\-Component\-Min\-Value ()} -\/ Specify the component for the column specified using Set\-Z\-Column() to use as the Zcoordinate in case the column is a multi-\/component array.  
\item {\ttfamily int = obj.\-Get\-Z\-Component\-Max\-Value ()} -\/ Specify the component for the column specified using Set\-Z\-Column() to use as the Zcoordinate in case the column is a multi-\/component array.  
\item {\ttfamily int = obj.\-Get\-Z\-Component ()} -\/ Specify the component for the column specified using Set\-Z\-Column() to use as the Zcoordinate in case the column is a multi-\/component array.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtktemporalpathlinefilter}{}\section{vtk\-Temporal\-Path\-Line\-Filter}\label{vtkgraphics_vtktemporalpathlinefilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Temporal\-Path\-Line\-Filter takes any dataset as input, it extracts the point locations of all cells over time to build up a polyline trail. The point number (index) is used as the 'key' if the points are randomly changing their respective order in the points list, then you should specify a scalar that represents the unique I\-D. This is intended to handle the output of a filter such as the Temporal\-Stream\-Tracer.

To create an instance of class vtk\-Temporal\-Path\-Line\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTemporalPathLineFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Temporal\-Path\-Line\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Temporal\-Path\-Line\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard Type-\/\-Macro  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard Type-\/\-Macro  
\item {\ttfamily vtk\-Temporal\-Path\-Line\-Filter = obj.\-New\-Instance ()} -\/ Standard Type-\/\-Macro  
\item {\ttfamily vtk\-Temporal\-Path\-Line\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard Type-\/\-Macro  
\item {\ttfamily obj.\-Set\-Mask\-Points (int )} -\/ Set the number of particles to track as a ratio of the input example\-: setting Mask\-Points to 10 will track every 10th point  
\item {\ttfamily int = obj.\-Get\-Mask\-Points ()} -\/ Set the number of particles to track as a ratio of the input example\-: setting Mask\-Points to 10 will track every 10th point  
\item {\ttfamily obj.\-Set\-Max\-Track\-Length (int )} -\/ If the Particles being traced animate for a long time, the trails or traces will become long and stringy. Setting the Max\-Trace\-Time\-Length will limit how much of the trace is displayed. Tracks longer then the Max will disappear and the trace will apppear like a snake of fixed length which progresses as the particle moves  
\item {\ttfamily int = obj.\-Get\-Max\-Track\-Length ()} -\/ If the Particles being traced animate for a long time, the trails or traces will become long and stringy. Setting the Max\-Trace\-Time\-Length will limit how much of the trace is displayed. Tracks longer then the Max will disappear and the trace will apppear like a snake of fixed length which progresses as the particle moves  
\item {\ttfamily obj.\-Set\-Id\-Channel\-Array (string )} -\/ Specify the name of a scalar array which will be used to fetch the index of each point. This is necessary only if the particles change position (Id order) on each time step. The Id can be used to identify particles at each step and hence track them properly. If this array is N\-U\-L\-L, the global point ids are used. If an Id array cannot otherwise be found, the point index is used as the I\-D.  
\item {\ttfamily string = obj.\-Get\-Id\-Channel\-Array ()} -\/ Specify the name of a scalar array which will be used to fetch the index of each point. This is necessary only if the particles change position (Id order) on each time step. The Id can be used to identify particles at each step and hence track them properly. If this array is N\-U\-L\-L, the global point ids are used. If an Id array cannot otherwise be found, the point index is used as the I\-D.  
\item {\ttfamily obj.\-Set\-Scalar\-Array (string )}  
\item {\ttfamily string = obj.\-Get\-Scalar\-Array ()}  
\item {\ttfamily obj.\-Set\-Max\-Step\-Distance (double , double , double )} -\/ If a particle disappears from one end of a simulation and reappears on the other side, the track left will be unrepresentative. Set a Max\-Step\-Distance\{x,y,z\} which acts as a threshold above which if a step occurs larger than the value (for the dimension), the track will be dropped and restarted after the step. (ie the part before the wrap around will be dropped and the newer part kept).  
\item {\ttfamily obj.\-Set\-Max\-Step\-Distance (double a\mbox{[}3\mbox{]})} -\/ If a particle disappears from one end of a simulation and reappears on the other side, the track left will be unrepresentative. Set a Max\-Step\-Distance\{x,y,z\} which acts as a threshold above which if a step occurs larger than the value (for the dimension), the track will be dropped and restarted after the step. (ie the part before the wrap around will be dropped and the newer part kept).  
\item {\ttfamily double = obj. Get\-Max\-Step\-Distance ()} -\/ If a particle disappears from one end of a simulation and reappears on the other side, the track left will be unrepresentative. Set a Max\-Step\-Distance\{x,y,z\} which acts as a threshold above which if a step occurs larger than the value (for the dimension), the track will be dropped and restarted after the step. (ie the part before the wrap around will be dropped and the newer part kept).  
\item {\ttfamily obj.\-Set\-Keep\-Dead\-Trails (int )} -\/ When a particle 'disappears', the trail belonging to it is removed from the list. When this flag is enabled, dead trails will persist until the next time the list is cleared. Use carefully as it may cause excessive memory consumption if left on by mistake.  
\item {\ttfamily int = obj.\-Get\-Keep\-Dead\-Trails ()} -\/ When a particle 'disappears', the trail belonging to it is removed from the list. When this flag is enabled, dead trails will persist until the next time the list is cleared. Use carefully as it may cause excessive memory consumption if left on by mistake.  
\item {\ttfamily obj.\-Flush ()} -\/ Flush will wipe any existing data so that traces can be restarted from whatever time step is next supplied.  
\item {\ttfamily obj.\-Set\-Selection\-Connection (vtk\-Algorithm\-Output alg\-Output)} -\/ Set a second input which is a selection. Particles with the same Id in the selection as the primary input will be chosen for pathlines Note that you must have the same Id\-Channel\-Array in the selection as the input  
\item {\ttfamily obj.\-Set\-Selection (vtk\-Data\-Set input)} -\/ Set a second input which is a selection. Particles with the same Id in the selection as the primary input will be chosen for pathlines Note that you must have the same Id\-Channel\-Array in the selection as the input  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtktemporalstatistics}{}\section{vtk\-Temporal\-Statistics}\label{vtkgraphics_vtktemporalstatistics}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Given an input that changes over time, vtk\-Temporal\-Statistics looks at the data for each time step and computes some statistical information of how a point or cell variable changes over time. For example, vtk\-Temporal\-Statistics can compute the average value of \char`\"{}pressure\char`\"{} over time of each point.

Note that this filter will require the upstream filter to be run on every time step that it reports that it can compute. This may be a time consuming operation.

vtk\-Temporal\-Statistics ignores the temporal spacing. Each timestep will be weighted the same regardless of how long of an interval it is to the next timestep. Thus, the average statistic may be quite different from an integration of the variable if the time spacing varies.

.S\-E\-C\-T\-I\-O\-N Thanks This class was originally written by Kenneth Moreland (\href{mailto:kmorel@sandia.gov}{\tt kmorel@sandia.\-gov}) from Sandia National Laboratories.

To create an instance of class vtk\-Temporal\-Statistics, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTemporalStatistics
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Temporal\-Statistics has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Temporal\-Statistics class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Temporal\-Statistics = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Temporal\-Statistics = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Compute\-Average ()} -\/ Turn on/off the computation of the average values over time. On by default. The resulting array names have \char`\"{}\-\_\-average\char`\"{} appended to them.  
\item {\ttfamily obj.\-Set\-Compute\-Average (int )} -\/ Turn on/off the computation of the average values over time. On by default. The resulting array names have \char`\"{}\-\_\-average\char`\"{} appended to them.  
\item {\ttfamily obj.\-Compute\-Average\-On ()} -\/ Turn on/off the computation of the average values over time. On by default. The resulting array names have \char`\"{}\-\_\-average\char`\"{} appended to them.  
\item {\ttfamily obj.\-Compute\-Average\-Off ()} -\/ Turn on/off the computation of the average values over time. On by default. The resulting array names have \char`\"{}\-\_\-average\char`\"{} appended to them.  
\item {\ttfamily int = obj.\-Get\-Compute\-Minimum ()} -\/ Turn on/off the computation of the minimum values over time. On by default. The resulting array names have \char`\"{}\-\_\-minimum\char`\"{} appended to them.  
\item {\ttfamily obj.\-Set\-Compute\-Minimum (int )} -\/ Turn on/off the computation of the minimum values over time. On by default. The resulting array names have \char`\"{}\-\_\-minimum\char`\"{} appended to them.  
\item {\ttfamily obj.\-Compute\-Minimum\-On ()} -\/ Turn on/off the computation of the minimum values over time. On by default. The resulting array names have \char`\"{}\-\_\-minimum\char`\"{} appended to them.  
\item {\ttfamily obj.\-Compute\-Minimum\-Off ()} -\/ Turn on/off the computation of the minimum values over time. On by default. The resulting array names have \char`\"{}\-\_\-minimum\char`\"{} appended to them.  
\item {\ttfamily int = obj.\-Get\-Compute\-Maximum ()} -\/ Turn on/off the computation of the maximum values over time. On by default. The resulting array names have \char`\"{}\-\_\-maximum\char`\"{} appended to them.  
\item {\ttfamily obj.\-Set\-Compute\-Maximum (int )} -\/ Turn on/off the computation of the maximum values over time. On by default. The resulting array names have \char`\"{}\-\_\-maximum\char`\"{} appended to them.  
\item {\ttfamily obj.\-Compute\-Maximum\-On ()} -\/ Turn on/off the computation of the maximum values over time. On by default. The resulting array names have \char`\"{}\-\_\-maximum\char`\"{} appended to them.  
\item {\ttfamily obj.\-Compute\-Maximum\-Off ()} -\/ Turn on/off the computation of the maximum values over time. On by default. The resulting array names have \char`\"{}\-\_\-maximum\char`\"{} appended to them.  
\item {\ttfamily int = obj.\-Get\-Compute\-Standard\-Deviation ()}  
\item {\ttfamily obj.\-Set\-Compute\-Standard\-Deviation (int )}  
\item {\ttfamily obj.\-Compute\-Standard\-Deviation\-On ()}  
\item {\ttfamily obj.\-Compute\-Standard\-Deviation\-Off ()}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtktensorglyph}{}\section{vtk\-Tensor\-Glyph}\label{vtkgraphics_vtktensorglyph}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Tensor\-Glyph is a filter that copies a geometric representation (specified as polygonal data) to every input point. The geometric representation, or glyph, can be scaled and/or rotated according to the tensor at the input point. Scaling and rotation is controlled by the eigenvalues/eigenvectors of the tensor as follows. For each tensor, the eigenvalues (and associated eigenvectors) are sorted to determine the major, medium, and minor eigenvalues/eigenvectors.

If the boolean variable Three\-Glyphs is not set the major eigenvalue scales the glyph in the x-\/direction, the medium in the y-\/direction, and the minor in the z-\/direction. Then, the glyph is rotated so that the glyph's local x-\/axis lies along the major eigenvector, y-\/axis along the medium eigenvector, and z-\/axis along the minor.

If the boolean variable Three\-Glyphs is set three glyphs are produced, each of them oriented along an eigenvector and scaled according to the corresponding eigenvector.

If the boolean variable Symmetric is set each glyph is mirrored (2 or 6 glyphs will be produced)

The x-\/axis of the source glyph will correspond to the eigenvector on output. Point (0,0,0) in the source will be placed in the data point. Variable Length will normally correspond to the distance from the origin to the tip of the source glyph along the x-\/axis, but can be changed to produce other results when Symmetric is on, e.\-g. glyphs that do not touch or that overlap.

Please note that when Symmetric is false it will generally be better to place the source glyph from (-\/0.\-5,0,0) to (0.\-5,0,0), i.\-e. centred at the origin. When symmetric is true the placement from (0,0,0) to (1,0,0) will generally be more convenient.

A scale factor is provided to control the amount of scaling. Also, you can turn off scaling completely if desired. The boolean variable Clamp\-Scaling controls the maximum scaling (in conjunction with Max\-Scale\-Factor.) This is useful in certain applications where singularities or large order of magnitude differences exist in the eigenvalues.

If the boolean variable Color\-Glyphs is set to true the glyphs are colored. The glyphs can be colored using the input scalars (Set\-Color\-Mode\-To\-Scalars), which is the default, or colored using the eigenvalues (Set\-Color\-Mode\-To\-Eigenvalues).

Another instance variable, Extract\-Eigenvalues, has been provided to control extraction of eigenvalues/eigenvectors. If this boolean is false, then eigenvalues/eigenvectors are not extracted, and the columns of the tensor are taken as the eigenvectors (the norm of column, always positive, is the eigenvalue). This allows additional capability over the vtk\-Glyph3\-D object. That is, the glyph can be oriented in three directions instead of one.

To create an instance of class vtk\-Tensor\-Glyph, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTensorGlyph
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Tensor\-Glyph has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Tensor\-Glyph class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Tensor\-Glyph = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Tensor\-Glyph = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Source (vtk\-Poly\-Data source)} -\/ Specify the geometry to copy to each point. Old style. See Set\-Source\-Connection.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Source ()} -\/ Specify the geometry to copy to each point. Old style. See Set\-Source\-Connection.  
\item {\ttfamily obj.\-Set\-Source\-Connection (int id, vtk\-Algorithm\-Output alg\-Output)} -\/ Specify a source object at a specified table location. New style. Source connection is stored in port 1. This method is equivalent to Set\-Input\-Connection(1, id, output\-Port).  
\item {\ttfamily obj.\-Set\-Source\-Connection (vtk\-Algorithm\-Output alg\-Output)} -\/ Turn on/off scaling of glyph with eigenvalues.  
\item {\ttfamily obj.\-Set\-Scaling (int )} -\/ Turn on/off scaling of glyph with eigenvalues.  
\item {\ttfamily int = obj.\-Get\-Scaling ()} -\/ Turn on/off scaling of glyph with eigenvalues.  
\item {\ttfamily obj.\-Scaling\-On ()} -\/ Turn on/off scaling of glyph with eigenvalues.  
\item {\ttfamily obj.\-Scaling\-Off ()} -\/ Turn on/off scaling of glyph with eigenvalues.  
\item {\ttfamily obj.\-Set\-Scale\-Factor (double )} -\/ Specify scale factor to scale object by. (Scale factor always affects output even if scaling is off.)  
\item {\ttfamily double = obj.\-Get\-Scale\-Factor ()} -\/ Specify scale factor to scale object by. (Scale factor always affects output even if scaling is off.)  
\item {\ttfamily obj.\-Set\-Three\-Glyphs (int )} -\/ Turn on/off drawing three glyphs  
\item {\ttfamily int = obj.\-Get\-Three\-Glyphs ()} -\/ Turn on/off drawing three glyphs  
\item {\ttfamily obj.\-Three\-Glyphs\-On ()} -\/ Turn on/off drawing three glyphs  
\item {\ttfamily obj.\-Three\-Glyphs\-Off ()} -\/ Turn on/off drawing three glyphs  
\item {\ttfamily obj.\-Set\-Symmetric (int )} -\/ Turn on/off drawing a mirror of each glyph  
\item {\ttfamily int = obj.\-Get\-Symmetric ()} -\/ Turn on/off drawing a mirror of each glyph  
\item {\ttfamily obj.\-Symmetric\-On ()} -\/ Turn on/off drawing a mirror of each glyph  
\item {\ttfamily obj.\-Symmetric\-Off ()} -\/ Turn on/off drawing a mirror of each glyph  
\item {\ttfamily obj.\-Set\-Length (double )} -\/ Set/\-Get the distance, along x, from the origin to the end of the source glyph. It is used to draw the symmetric glyphs.  
\item {\ttfamily double = obj.\-Get\-Length ()} -\/ Set/\-Get the distance, along x, from the origin to the end of the source glyph. It is used to draw the symmetric glyphs.  
\item {\ttfamily obj.\-Set\-Extract\-Eigenvalues (int )} -\/ Turn on/off extraction of eigenvalues from tensor.  
\item {\ttfamily obj.\-Extract\-Eigenvalues\-On ()} -\/ Turn on/off extraction of eigenvalues from tensor.  
\item {\ttfamily obj.\-Extract\-Eigenvalues\-Off ()} -\/ Turn on/off extraction of eigenvalues from tensor.  
\item {\ttfamily int = obj.\-Get\-Extract\-Eigenvalues ()} -\/ Turn on/off extraction of eigenvalues from tensor.  
\item {\ttfamily obj.\-Set\-Color\-Glyphs (int )} -\/ Turn on/off coloring of glyph with input scalar data or eigenvalues. If false, or input scalar data not present, then the scalars from the source object are passed through the filter.  
\item {\ttfamily int = obj.\-Get\-Color\-Glyphs ()} -\/ Turn on/off coloring of glyph with input scalar data or eigenvalues. If false, or input scalar data not present, then the scalars from the source object are passed through the filter.  
\item {\ttfamily obj.\-Color\-Glyphs\-On ()} -\/ Turn on/off coloring of glyph with input scalar data or eigenvalues. If false, or input scalar data not present, then the scalars from the source object are passed through the filter.  
\item {\ttfamily obj.\-Color\-Glyphs\-Off ()} -\/ Turn on/off coloring of glyph with input scalar data or eigenvalues. If false, or input scalar data not present, then the scalars from the source object are passed through the filter.  
\item {\ttfamily obj.\-Set\-Color\-Mode (int )} -\/ Set the color mode to be used for the glyphs. This can be set to use the input scalars (default) or to use the eigenvalues at the point. If Three\-Glyphs is set and the eigenvalues are chosen for coloring then each glyph is colored by the corresponding eigenvalue and if not set the color corresponding to the largest eigenvalue is chosen. The recognized values are\-: C\-O\-L\-O\-R\-\_\-\-B\-Y\-\_\-\-S\-C\-A\-L\-A\-R\-S = 0 (default) C\-O\-L\-O\-R\-\_\-\-B\-Y\-\_\-\-E\-I\-G\-E\-N\-V\-A\-L\-U\-E\-S = 1  
\item {\ttfamily int = obj.\-Get\-Color\-Mode\-Min\-Value ()} -\/ Set the color mode to be used for the glyphs. This can be set to use the input scalars (default) or to use the eigenvalues at the point. If Three\-Glyphs is set and the eigenvalues are chosen for coloring then each glyph is colored by the corresponding eigenvalue and if not set the color corresponding to the largest eigenvalue is chosen. The recognized values are\-: C\-O\-L\-O\-R\-\_\-\-B\-Y\-\_\-\-S\-C\-A\-L\-A\-R\-S = 0 (default) C\-O\-L\-O\-R\-\_\-\-B\-Y\-\_\-\-E\-I\-G\-E\-N\-V\-A\-L\-U\-E\-S = 1  
\item {\ttfamily int = obj.\-Get\-Color\-Mode\-Max\-Value ()} -\/ Set the color mode to be used for the glyphs. This can be set to use the input scalars (default) or to use the eigenvalues at the point. If Three\-Glyphs is set and the eigenvalues are chosen for coloring then each glyph is colored by the corresponding eigenvalue and if not set the color corresponding to the largest eigenvalue is chosen. The recognized values are\-: C\-O\-L\-O\-R\-\_\-\-B\-Y\-\_\-\-S\-C\-A\-L\-A\-R\-S = 0 (default) C\-O\-L\-O\-R\-\_\-\-B\-Y\-\_\-\-E\-I\-G\-E\-N\-V\-A\-L\-U\-E\-S = 1  
\item {\ttfamily int = obj.\-Get\-Color\-Mode ()} -\/ Set the color mode to be used for the glyphs. This can be set to use the input scalars (default) or to use the eigenvalues at the point. If Three\-Glyphs is set and the eigenvalues are chosen for coloring then each glyph is colored by the corresponding eigenvalue and if not set the color corresponding to the largest eigenvalue is chosen. The recognized values are\-: C\-O\-L\-O\-R\-\_\-\-B\-Y\-\_\-\-S\-C\-A\-L\-A\-R\-S = 0 (default) C\-O\-L\-O\-R\-\_\-\-B\-Y\-\_\-\-E\-I\-G\-E\-N\-V\-A\-L\-U\-E\-S = 1  
\item {\ttfamily obj.\-Set\-Color\-Mode\-To\-Scalars ()} -\/ Set the color mode to be used for the glyphs. This can be set to use the input scalars (default) or to use the eigenvalues at the point. If Three\-Glyphs is set and the eigenvalues are chosen for coloring then each glyph is colored by the corresponding eigenvalue and if not set the color corresponding to the largest eigenvalue is chosen. The recognized values are\-: C\-O\-L\-O\-R\-\_\-\-B\-Y\-\_\-\-S\-C\-A\-L\-A\-R\-S = 0 (default) C\-O\-L\-O\-R\-\_\-\-B\-Y\-\_\-\-E\-I\-G\-E\-N\-V\-A\-L\-U\-E\-S = 1  
\item {\ttfamily obj.\-Set\-Color\-Mode\-To\-Eigenvalues ()} -\/ Set the color mode to be used for the glyphs. This can be set to use the input scalars (default) or to use the eigenvalues at the point. If Three\-Glyphs is set and the eigenvalues are chosen for coloring then each glyph is colored by the corresponding eigenvalue and if not set the color corresponding to the largest eigenvalue is chosen. The recognized values are\-: C\-O\-L\-O\-R\-\_\-\-B\-Y\-\_\-\-S\-C\-A\-L\-A\-R\-S = 0 (default) C\-O\-L\-O\-R\-\_\-\-B\-Y\-\_\-\-E\-I\-G\-E\-N\-V\-A\-L\-U\-E\-S = 1  
\item {\ttfamily obj.\-Set\-Clamp\-Scaling (int )} -\/ Turn on/off scalar clamping. If scalar clamping is on, the ivar Max\-Scale\-Factor is used to control the maximum scale factor. (This is useful to prevent uncontrolled scaling near singularities.)  
\item {\ttfamily int = obj.\-Get\-Clamp\-Scaling ()} -\/ Turn on/off scalar clamping. If scalar clamping is on, the ivar Max\-Scale\-Factor is used to control the maximum scale factor. (This is useful to prevent uncontrolled scaling near singularities.)  
\item {\ttfamily obj.\-Clamp\-Scaling\-On ()} -\/ Turn on/off scalar clamping. If scalar clamping is on, the ivar Max\-Scale\-Factor is used to control the maximum scale factor. (This is useful to prevent uncontrolled scaling near singularities.)  
\item {\ttfamily obj.\-Clamp\-Scaling\-Off ()} -\/ Turn on/off scalar clamping. If scalar clamping is on, the ivar Max\-Scale\-Factor is used to control the maximum scale factor. (This is useful to prevent uncontrolled scaling near singularities.)  
\item {\ttfamily obj.\-Set\-Max\-Scale\-Factor (double )} -\/ Set/\-Get the maximum allowable scale factor. This value is compared to the combination of the scale factor times the eigenvalue. If less, the scale factor is reset to the Max\-Scale\-Factor. The boolean Clamp\-Scaling has to be \char`\"{}on\char`\"{} for this to work.  
\item {\ttfamily double = obj.\-Get\-Max\-Scale\-Factor ()} -\/ Set/\-Get the maximum allowable scale factor. This value is compared to the combination of the scale factor times the eigenvalue. If less, the scale factor is reset to the Max\-Scale\-Factor. The boolean Clamp\-Scaling has to be \char`\"{}on\char`\"{} for this to work.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtktessellatedboxsource}{}\section{vtk\-Tessellated\-Box\-Source}\label{vtkgraphics_vtktessellatedboxsource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Tessellated\-Box\-Source creates a axis-\/aligned box defined by its bounds and a level of subdivision. Connectivity is strong\-: points of the vertices and inside the edges are shared between faces. In other words, faces are connected. Each face looks like a grid of quads, each quad is composed of 2 triangles. Given a level of subdivision `l', each edge has `l'+2 points, `l' of them are internal edge points, the 2 other ones are the vertices. Each face has a total of (`l'+2)$\ast$(`l'+2) points, 4 of them are vertices, 4$\ast$`l' are internal edge points, it remains `l'$^\wedge$2 internal face points.

This source only generate geometry, no Data\-Arrays like normals or texture coordinates.

To create an instance of class vtk\-Tessellated\-Box\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTessellatedBoxSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Tessellated\-Box\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Tessellated\-Box\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Tessellated\-Box\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Tessellated\-Box\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Bounds (double , double , double , double , double , double )} -\/ Set the bounds of the box. See Get\-Bounds() for a detail description. \begin{DoxyPrecond}{Precondition}
xmin$<$=xmax \&\& ymin$<$=ymax \&\& zmin$<$zmax  
\end{DoxyPrecond}

\item {\ttfamily obj.\-Set\-Bounds (double a\mbox{[}6\mbox{]})} -\/ Set the bounds of the box. See Get\-Bounds() for a detail description. \begin{DoxyPrecond}{Precondition}
xmin$<$=xmax \&\& ymin$<$=ymax \&\& zmin$<$zmax  
\end{DoxyPrecond}

\item {\ttfamily double = obj. Get\-Bounds ()} -\/ Bounds of the box in world coordinates. This a 6-\/uple of xmin,xmax,ymin, ymax,zmin and zmax. Initial value is (-\/0.\-5,0.\-5,-\/0.\-5,0.\-5,-\/0.\-5,0.\-5), bounds of a cube of length 1 centered at (0,0,0). Bounds are defined such that xmin$<$=xmax, ymin$<$=ymax and zmin$<$zmax. \begin{DoxyPostcond}{Postcondition}
xmin$<$=xmax \&\& ymin$<$=ymax \&\& zmin$<$zmax  
\end{DoxyPostcond}

\item {\ttfamily obj.\-Set\-Level (int )} -\/ Set the level of subdivision of the faces. \begin{DoxyPrecond}{Precondition}
positive\-\_\-level\-: level$>$=0  
\end{DoxyPrecond}

\item {\ttfamily int = obj.\-Get\-Level ()} -\/ Level of subdivision of the faces. Initial value is 0. \begin{DoxyPostcond}{Postcondition}
positive\-\_\-level\-: level$>$=0  
\end{DoxyPostcond}

\item {\ttfamily obj.\-Set\-Duplicate\-Shared\-Points (int )} -\/ Flag to tell the source to duplicate points shared between faces (vertices of the box and internal edge points). Initial value is false. Implementation note\-: duplicating points is an easier method to implement than a minimal number of points.  
\item {\ttfamily int = obj.\-Get\-Duplicate\-Shared\-Points ()} -\/ Flag to tell the source to duplicate points shared between faces (vertices of the box and internal edge points). Initial value is false. Implementation note\-: duplicating points is an easier method to implement than a minimal number of points.  
\item {\ttfamily obj.\-Duplicate\-Shared\-Points\-On ()} -\/ Flag to tell the source to duplicate points shared between faces (vertices of the box and internal edge points). Initial value is false. Implementation note\-: duplicating points is an easier method to implement than a minimal number of points.  
\item {\ttfamily obj.\-Duplicate\-Shared\-Points\-Off ()} -\/ Flag to tell the source to duplicate points shared between faces (vertices of the box and internal edge points). Initial value is false. Implementation note\-: duplicating points is an easier method to implement than a minimal number of points.  
\item {\ttfamily obj.\-Set\-Quads (int )} -\/ Flag to tell the source to generate either a quad or two triangle for a set of four points. Initial value is false (generate triangles).  
\item {\ttfamily int = obj.\-Get\-Quads ()} -\/ Flag to tell the source to generate either a quad or two triangle for a set of four points. Initial value is false (generate triangles).  
\item {\ttfamily obj.\-Quads\-On ()} -\/ Flag to tell the source to generate either a quad or two triangle for a set of four points. Initial value is false (generate triangles).  
\item {\ttfamily obj.\-Quads\-Off ()} -\/ Flag to tell the source to generate either a quad or two triangle for a set of four points. Initial value is false (generate triangles).  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtktessellatorfilter}{}\section{vtk\-Tessellator\-Filter}\label{vtkgraphics_vtktessellatorfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class approximates nonlinear F\-E\-M elements with linear simplices.

{\bfseries Warning}\-: This class is temporary and will go away at some point after Para\-View 1.\-4.\-0.

This filter rifles through all the cells in an input vtk\-Data\-Set. It tesselates each cell and uses the vtk\-Streaming\-Tessellator and vtk\-Data\-Set\-Edge\-Subdivision\-Criterion classes to generate simplices that approximate the nonlinear mesh using some approximation metric (encoded in the particular vtk\-Data\-Set\-Edge\-Subdivision\-Criterion\-::\-Evaluate\-Edge implementation). The simplices are placed into the filter's output vtk\-Data\-Set object by the callback routines Add\-A\-Tetrahedron, Add\-A\-Triangle, and Add\-A\-Line, which are registered with the triangulator.

The output mesh will have geometry and any fields specified as attributes in the input mesh's point data. The attribute's copy flags are honored, except for normals.

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

The filter's main member function is Request\-Data(). This function first calls Setup\-Output() which allocates arrays and some temporary variables for the primitive callbacks (Output\-Triangle and Output\-Line which are called by Add\-A\-Triangle and Add\-A\-Line, respectively). Each cell is given an initial tesselation, which results in one or more calls to Output\-Tetrahedron, Output\-Triangle or Output\-Line to add elements to the Output\-Mesh. Finally, Teardown() is called to free the filter's working space.

To create an instance of class vtk\-Tessellator\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTessellatorFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Tessellator\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Tessellator\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Tessellator\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Tessellator\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Tessellator (vtk\-Streaming\-Tessellator )}  
\item {\ttfamily vtk\-Streaming\-Tessellator = obj.\-Get\-Tessellator ()}  
\item {\ttfamily obj.\-Set\-Subdivider (vtk\-Data\-Set\-Edge\-Subdivision\-Criterion )}  
\item {\ttfamily vtk\-Data\-Set\-Edge\-Subdivision\-Criterion = obj.\-Get\-Subdivider ()}  
\item {\ttfamily long = obj.\-Get\-M\-Time ()}  
\item {\ttfamily obj.\-Set\-Output\-Dimension (int )} -\/ Set the dimension of the output tessellation. Cells in dimensions higher than the given value will have their boundaries of dimension {\itshape Output\-Dimension} tessellated. For example, if {\itshape Output\-Dimension} is 2, a hexahedron's quadrilateral faces would be tessellated rather than its interior.  
\item {\ttfamily int = obj.\-Get\-Output\-Dimension\-Min\-Value ()} -\/ Set the dimension of the output tessellation. Cells in dimensions higher than the given value will have their boundaries of dimension {\itshape Output\-Dimension} tessellated. For example, if {\itshape Output\-Dimension} is 2, a hexahedron's quadrilateral faces would be tessellated rather than its interior.  
\item {\ttfamily int = obj.\-Get\-Output\-Dimension\-Max\-Value ()} -\/ Set the dimension of the output tessellation. Cells in dimensions higher than the given value will have their boundaries of dimension {\itshape Output\-Dimension} tessellated. For example, if {\itshape Output\-Dimension} is 2, a hexahedron's quadrilateral faces would be tessellated rather than its interior.  
\item {\ttfamily int = obj.\-Get\-Output\-Dimension ()} -\/ Set the dimension of the output tessellation. Cells in dimensions higher than the given value will have their boundaries of dimension {\itshape Output\-Dimension} tessellated. For example, if {\itshape Output\-Dimension} is 2, a hexahedron's quadrilateral faces would be tessellated rather than its interior.  
\item {\ttfamily obj.\-Set\-Maximum\-Number\-Of\-Subdivisions (int num\-\_\-subdiv\-\_\-in)} -\/ These are convenience routines for setting properties maintained by the tessellator and subdivider. They are implemented here for Para\-View's sake.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Number\-Of\-Subdivisions ()} -\/ These are convenience routines for setting properties maintained by the tessellator and subdivider. They are implemented here for Para\-View's sake.  
\item {\ttfamily obj.\-Set\-Chord\-Error (double ce)} -\/ These are convenience routines for setting properties maintained by the tessellator and subdivider. They are implemented here for Para\-View's sake.  
\item {\ttfamily double = obj.\-Get\-Chord\-Error ()} -\/ These are convenience routines for setting properties maintained by the tessellator and subdivider. They are implemented here for Para\-View's sake.  
\item {\ttfamily obj.\-Reset\-Field\-Criteria ()} -\/ These methods are for the Para\-View client.  
\item {\ttfamily obj.\-Set\-Field\-Criterion (int field, double chord)} -\/ These methods are for the Para\-View client.  
\item {\ttfamily int = obj.\-Get\-Merge\-Points ()} -\/ The adaptive tessellation will output vertices that are not shared among cells, even where they should be. This can be corrected to some extents with a vtk\-Merge\-Filter. By default, the filter is off and vertices will not be shared.  
\item {\ttfamily obj.\-Set\-Merge\-Points (int )} -\/ The adaptive tessellation will output vertices that are not shared among cells, even where they should be. This can be corrected to some extents with a vtk\-Merge\-Filter. By default, the filter is off and vertices will not be shared.  
\item {\ttfamily obj.\-Merge\-Points\-On ()} -\/ The adaptive tessellation will output vertices that are not shared among cells, even where they should be. This can be corrected to some extents with a vtk\-Merge\-Filter. By default, the filter is off and vertices will not be shared.  
\item {\ttfamily obj.\-Merge\-Points\-Off ()} -\/ The adaptive tessellation will output vertices that are not shared among cells, even where they should be. This can be corrected to some extents with a vtk\-Merge\-Filter. By default, the filter is off and vertices will not be shared.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtktextsource}{}\section{vtk\-Text\-Source}\label{vtkgraphics_vtktextsource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Text\-Source converts a text string into polygons. This way you can insert text into your renderings. It uses the 9x15 font from X Windows. You can specify if you want the background to be drawn or not. The characters are formed by scan converting the raster font into quadrilaterals. Colors are assigned to the letters using scalar data. To set the color of the characters with the source's actor property, set Backing\-Off on the text source and Scalar\-Visibility\-Off on the associated vtk\-Poly\-Data\-Mapper. Then, the color can be set using the associated actor's property.

vtk\-Vector\-Text generates higher quality polygonal representations of characters.

To create an instance of class vtk\-Text\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTextSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Text\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Text\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Text\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Text\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Text (string )} -\/ Set/\-Get the text to be drawn.  
\item {\ttfamily string = obj.\-Get\-Text ()} -\/ Set/\-Get the text to be drawn.  
\item {\ttfamily obj.\-Set\-Backing (int )} -\/ Controls whether or not a background is drawn with the text.  
\item {\ttfamily int = obj.\-Get\-Backing ()} -\/ Controls whether or not a background is drawn with the text.  
\item {\ttfamily obj.\-Backing\-On ()} -\/ Controls whether or not a background is drawn with the text.  
\item {\ttfamily obj.\-Backing\-Off ()} -\/ Controls whether or not a background is drawn with the text.  
\item {\ttfamily obj.\-Set\-Foreground\-Color (double , double , double )} -\/ Set/\-Get the foreground color. Default is white (1,1,1). A\-Lpha is always 1.  
\item {\ttfamily obj.\-Set\-Foreground\-Color (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the foreground color. Default is white (1,1,1). A\-Lpha is always 1.  
\item {\ttfamily double = obj. Get\-Foreground\-Color ()} -\/ Set/\-Get the foreground color. Default is white (1,1,1). A\-Lpha is always 1.  
\item {\ttfamily obj.\-Set\-Background\-Color (double , double , double )} -\/ Set/\-Get the background color. Default is black (0,0,0). Alpha is always 1.  
\item {\ttfamily obj.\-Set\-Background\-Color (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the background color. Default is black (0,0,0). Alpha is always 1.  
\item {\ttfamily double = obj. Get\-Background\-Color ()} -\/ Set/\-Get the background color. Default is black (0,0,0). Alpha is always 1.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtktexturedspheresource}{}\section{vtk\-Textured\-Sphere\-Source}\label{vtkgraphics_vtktexturedspheresource}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Textured\-Sphere\-Source creates a polygonal sphere of specified radius centered at the origin. The resolution (polygonal discretization) in both the latitude (phi) and longitude (theta) directions can be specified. It also is possible to create partial sphere by specifying maximum phi and theta angles.

To create an instance of class vtk\-Textured\-Sphere\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTexturedSphereSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Textured\-Sphere\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Textured\-Sphere\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Textured\-Sphere\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Textured\-Sphere\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Radius (double )} -\/ Set radius of sphere.  
\item {\ttfamily double = obj.\-Get\-Radius\-Min\-Value ()} -\/ Set radius of sphere.  
\item {\ttfamily double = obj.\-Get\-Radius\-Max\-Value ()} -\/ Set radius of sphere.  
\item {\ttfamily double = obj.\-Get\-Radius ()} -\/ Set radius of sphere.  
\item {\ttfamily obj.\-Set\-Theta\-Resolution (int )} -\/ Set the number of points in the longitude direction.  
\item {\ttfamily int = obj.\-Get\-Theta\-Resolution\-Min\-Value ()} -\/ Set the number of points in the longitude direction.  
\item {\ttfamily int = obj.\-Get\-Theta\-Resolution\-Max\-Value ()} -\/ Set the number of points in the longitude direction.  
\item {\ttfamily int = obj.\-Get\-Theta\-Resolution ()} -\/ Set the number of points in the longitude direction.  
\item {\ttfamily obj.\-Set\-Phi\-Resolution (int )} -\/ Set the number of points in the latitude direction.  
\item {\ttfamily int = obj.\-Get\-Phi\-Resolution\-Min\-Value ()} -\/ Set the number of points in the latitude direction.  
\item {\ttfamily int = obj.\-Get\-Phi\-Resolution\-Max\-Value ()} -\/ Set the number of points in the latitude direction.  
\item {\ttfamily int = obj.\-Get\-Phi\-Resolution ()} -\/ Set the number of points in the latitude direction.  
\item {\ttfamily obj.\-Set\-Theta (double )} -\/ Set the maximum longitude angle.  
\item {\ttfamily double = obj.\-Get\-Theta\-Min\-Value ()} -\/ Set the maximum longitude angle.  
\item {\ttfamily double = obj.\-Get\-Theta\-Max\-Value ()} -\/ Set the maximum longitude angle.  
\item {\ttfamily double = obj.\-Get\-Theta ()} -\/ Set the maximum longitude angle.  
\item {\ttfamily obj.\-Set\-Phi (double )} -\/ Set the maximum latitude angle (0 is at north pole).  
\item {\ttfamily double = obj.\-Get\-Phi\-Min\-Value ()} -\/ Set the maximum latitude angle (0 is at north pole).  
\item {\ttfamily double = obj.\-Get\-Phi\-Max\-Value ()} -\/ Set the maximum latitude angle (0 is at north pole).  
\item {\ttfamily double = obj.\-Get\-Phi ()} -\/ Set the maximum latitude angle (0 is at north pole).  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtktexturemaptocylinder}{}\section{vtk\-Texture\-Map\-To\-Cylinder}\label{vtkgraphics_vtktexturemaptocylinder}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Texture\-Map\-To\-Cylinder is a filter that generates 2\-D texture coordinates by mapping input dataset points onto a cylinder. The cylinder can either be user specified or generated automatically. (The cylinder is generated automatically by computing the axis of the cylinder.) Note that the generated texture coordinates for the s-\/coordinate ranges from (0-\/1) (corresponding to angle of 0-\/$>$360 around axis), while the mapping of the t-\/coordinate is controlled by the projection of points along the axis.

To specify a cylinder manually, you must provide two points that define the axis of the cylinder. The length of the axis will affect the t-\/coordinates.

A special ivar controls how the s-\/coordinate is generated. If Prevent\-Seam is set to true, the s-\/texture varies from 0-\/$>$1 and then 1-\/$>$0 (corresponding to angles of 0-\/$>$180 and 180-\/$>$360).

To create an instance of class vtk\-Texture\-Map\-To\-Cylinder, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTextureMapToCylinder
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Texture\-Map\-To\-Cylinder has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Texture\-Map\-To\-Cylinder class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Texture\-Map\-To\-Cylinder = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Texture\-Map\-To\-Cylinder = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Point1 (double , double , double )} -\/ Specify the first point defining the cylinder axis,  
\item {\ttfamily obj.\-Set\-Point1 (double a\mbox{[}3\mbox{]})} -\/ Specify the first point defining the cylinder axis,  
\item {\ttfamily double = obj. Get\-Point1 ()} -\/ Specify the first point defining the cylinder axis,  
\item {\ttfamily obj.\-Set\-Point2 (double , double , double )} -\/ Specify the second point defining the cylinder axis,  
\item {\ttfamily obj.\-Set\-Point2 (double a\mbox{[}3\mbox{]})} -\/ Specify the second point defining the cylinder axis,  
\item {\ttfamily double = obj. Get\-Point2 ()} -\/ Specify the second point defining the cylinder axis,  
\item {\ttfamily obj.\-Set\-Automatic\-Cylinder\-Generation (int )} -\/ Turn on/off automatic cylinder generation. This means it automatically finds the cylinder center and axis.  
\item {\ttfamily int = obj.\-Get\-Automatic\-Cylinder\-Generation ()} -\/ Turn on/off automatic cylinder generation. This means it automatically finds the cylinder center and axis.  
\item {\ttfamily obj.\-Automatic\-Cylinder\-Generation\-On ()} -\/ Turn on/off automatic cylinder generation. This means it automatically finds the cylinder center and axis.  
\item {\ttfamily obj.\-Automatic\-Cylinder\-Generation\-Off ()} -\/ Turn on/off automatic cylinder generation. This means it automatically finds the cylinder center and axis.  
\item {\ttfamily obj.\-Set\-Prevent\-Seam (int )} -\/ Control how the texture coordinates are generated. If Prevent\-Seam is set, the s-\/coordinate ranges from 0-\/$>$1 and 1-\/$>$0 corresponding to the angle variation from 0-\/$>$180 and 180-\/$>$0. Otherwise, the s-\/coordinate ranges from 0-\/$>$1 from 0-\/$>$360 degrees.  
\item {\ttfamily int = obj.\-Get\-Prevent\-Seam ()} -\/ Control how the texture coordinates are generated. If Prevent\-Seam is set, the s-\/coordinate ranges from 0-\/$>$1 and 1-\/$>$0 corresponding to the angle variation from 0-\/$>$180 and 180-\/$>$0. Otherwise, the s-\/coordinate ranges from 0-\/$>$1 from 0-\/$>$360 degrees.  
\item {\ttfamily obj.\-Prevent\-Seam\-On ()} -\/ Control how the texture coordinates are generated. If Prevent\-Seam is set, the s-\/coordinate ranges from 0-\/$>$1 and 1-\/$>$0 corresponding to the angle variation from 0-\/$>$180 and 180-\/$>$0. Otherwise, the s-\/coordinate ranges from 0-\/$>$1 from 0-\/$>$360 degrees.  
\item {\ttfamily obj.\-Prevent\-Seam\-Off ()} -\/ Control how the texture coordinates are generated. If Prevent\-Seam is set, the s-\/coordinate ranges from 0-\/$>$1 and 1-\/$>$0 corresponding to the angle variation from 0-\/$>$180 and 180-\/$>$0. Otherwise, the s-\/coordinate ranges from 0-\/$>$1 from 0-\/$>$360 degrees.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtktexturemaptoplane}{}\section{vtk\-Texture\-Map\-To\-Plane}\label{vtkgraphics_vtktexturemaptoplane}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Texture\-Map\-To\-Plane is a filter that generates 2\-D texture coordinates by mapping input dataset points onto a plane. The plane can either be user specified or generated automatically. (A least squares method is used to generate the plane automatically.)

There are two ways you can specify the plane. The first is to provide a plane normal. In this case the points are projected to a plane, and the points are then mapped into the user specified s-\/t coordinate range. For more control, you can specify a plane with three points\-: an origin and two points defining the two axes of the plane. (This is compatible with the vtk\-Plane\-Source.) Using the second method, the S\-Range and T\-Range vectors are ignored, since the presumption is that the user does not want to scale the texture coordinates; and you can adjust the origin and axes points to achieve the texture coordinate scaling you need. Note also that using the three point method the axes do not have to be orthogonal.

To create an instance of class vtk\-Texture\-Map\-To\-Plane, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTextureMapToPlane
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Texture\-Map\-To\-Plane has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Texture\-Map\-To\-Plane class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Texture\-Map\-To\-Plane = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Texture\-Map\-To\-Plane = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Origin (double , double , double )} -\/ Specify a point defining the origin of the plane. Used in conjunction with the Point1 and Point2 ivars to specify a map plane.  
\item {\ttfamily obj.\-Set\-Origin (double a\mbox{[}3\mbox{]})} -\/ Specify a point defining the origin of the plane. Used in conjunction with the Point1 and Point2 ivars to specify a map plane.  
\item {\ttfamily double = obj. Get\-Origin ()} -\/ Specify a point defining the origin of the plane. Used in conjunction with the Point1 and Point2 ivars to specify a map plane.  
\item {\ttfamily obj.\-Set\-Point1 (double , double , double )} -\/ Specify a point defining the first axis of the plane.  
\item {\ttfamily obj.\-Set\-Point1 (double a\mbox{[}3\mbox{]})} -\/ Specify a point defining the first axis of the plane.  
\item {\ttfamily double = obj. Get\-Point1 ()} -\/ Specify a point defining the first axis of the plane.  
\item {\ttfamily obj.\-Set\-Point2 (double , double , double )} -\/ Specify a point defining the second axis of the plane.  
\item {\ttfamily obj.\-Set\-Point2 (double a\mbox{[}3\mbox{]})} -\/ Specify a point defining the second axis of the plane.  
\item {\ttfamily double = obj. Get\-Point2 ()} -\/ Specify a point defining the second axis of the plane.  
\item {\ttfamily obj.\-Set\-Normal (double , double , double )} -\/ Specify plane normal. An alternative way to specify a map plane. Using this method, the object will scale the resulting texture coordinate between the S\-Range and T\-Range specified.  
\item {\ttfamily obj.\-Set\-Normal (double a\mbox{[}3\mbox{]})} -\/ Specify plane normal. An alternative way to specify a map plane. Using this method, the object will scale the resulting texture coordinate between the S\-Range and T\-Range specified.  
\item {\ttfamily double = obj. Get\-Normal ()} -\/ Specify plane normal. An alternative way to specify a map plane. Using this method, the object will scale the resulting texture coordinate between the S\-Range and T\-Range specified.  
\item {\ttfamily obj.\-Set\-S\-Range (double , double )} -\/ Specify s-\/coordinate range for texture s-\/t coordinate pair.  
\item {\ttfamily obj.\-Set\-S\-Range (double a\mbox{[}2\mbox{]})} -\/ Specify s-\/coordinate range for texture s-\/t coordinate pair.  
\item {\ttfamily double = obj. Get\-S\-Range ()} -\/ Specify s-\/coordinate range for texture s-\/t coordinate pair.  
\item {\ttfamily obj.\-Set\-T\-Range (double , double )} -\/ Specify t-\/coordinate range for texture s-\/t coordinate pair.  
\item {\ttfamily obj.\-Set\-T\-Range (double a\mbox{[}2\mbox{]})} -\/ Specify t-\/coordinate range for texture s-\/t coordinate pair.  
\item {\ttfamily double = obj. Get\-T\-Range ()} -\/ Specify t-\/coordinate range for texture s-\/t coordinate pair.  
\item {\ttfamily obj.\-Set\-Automatic\-Plane\-Generation (int )} -\/ Turn on/off automatic plane generation.  
\item {\ttfamily int = obj.\-Get\-Automatic\-Plane\-Generation ()} -\/ Turn on/off automatic plane generation.  
\item {\ttfamily obj.\-Automatic\-Plane\-Generation\-On ()} -\/ Turn on/off automatic plane generation.  
\item {\ttfamily obj.\-Automatic\-Plane\-Generation\-Off ()} -\/ Turn on/off automatic plane generation.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtktexturemaptosphere}{}\section{vtk\-Texture\-Map\-To\-Sphere}\label{vtkgraphics_vtktexturemaptosphere}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Texture\-Map\-To\-Sphere is a filter that generates 2\-D texture coordinates by mapping input dataset points onto a sphere. The sphere can either be user specified or generated automatically. (The sphere is generated automatically by computing the center (i.\-e., averaged coordinates) of the sphere.) Note that the generated texture coordinates range between (0,1). The s-\/coordinate lies in the angular direction around the z-\/axis, measured counter-\/clockwise from the x-\/axis. The t-\/coordinate lies in the angular direction measured down from the north pole towards the south pole.

A special ivar controls how the s-\/coordinate is generated. If Prevent\-Seam is set to true, the s-\/texture varies from 0-\/$>$1 and then 1-\/$>$0 (corresponding to angles of 0-\/$>$180 and 180-\/$>$360).

To create an instance of class vtk\-Texture\-Map\-To\-Sphere, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTextureMapToSphere
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Texture\-Map\-To\-Sphere has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Texture\-Map\-To\-Sphere class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Texture\-Map\-To\-Sphere = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Texture\-Map\-To\-Sphere = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Center (double , double , double )} -\/ Specify a point defining the center of the sphere.  
\item {\ttfamily obj.\-Set\-Center (double a\mbox{[}3\mbox{]})} -\/ Specify a point defining the center of the sphere.  
\item {\ttfamily double = obj. Get\-Center ()} -\/ Specify a point defining the center of the sphere.  
\item {\ttfamily obj.\-Set\-Automatic\-Sphere\-Generation (int )} -\/ Turn on/off automatic sphere generation. This means it automatically finds the sphere center.  
\item {\ttfamily int = obj.\-Get\-Automatic\-Sphere\-Generation ()} -\/ Turn on/off automatic sphere generation. This means it automatically finds the sphere center.  
\item {\ttfamily obj.\-Automatic\-Sphere\-Generation\-On ()} -\/ Turn on/off automatic sphere generation. This means it automatically finds the sphere center.  
\item {\ttfamily obj.\-Automatic\-Sphere\-Generation\-Off ()} -\/ Turn on/off automatic sphere generation. This means it automatically finds the sphere center.  
\item {\ttfamily obj.\-Set\-Prevent\-Seam (int )} -\/ Control how the texture coordinates are generated. If Prevent\-Seam is set, the s-\/coordinate ranges from 0-\/$>$1 and 1-\/$>$0 corresponding to the theta angle variation between 0-\/$>$180 and 180-\/$>$0 degrees. Otherwise, the s-\/coordinate ranges from 0-\/$>$1 between 0-\/$>$360 degrees.  
\item {\ttfamily int = obj.\-Get\-Prevent\-Seam ()} -\/ Control how the texture coordinates are generated. If Prevent\-Seam is set, the s-\/coordinate ranges from 0-\/$>$1 and 1-\/$>$0 corresponding to the theta angle variation between 0-\/$>$180 and 180-\/$>$0 degrees. Otherwise, the s-\/coordinate ranges from 0-\/$>$1 between 0-\/$>$360 degrees.  
\item {\ttfamily obj.\-Prevent\-Seam\-On ()} -\/ Control how the texture coordinates are generated. If Prevent\-Seam is set, the s-\/coordinate ranges from 0-\/$>$1 and 1-\/$>$0 corresponding to the theta angle variation between 0-\/$>$180 and 180-\/$>$0 degrees. Otherwise, the s-\/coordinate ranges from 0-\/$>$1 between 0-\/$>$360 degrees.  
\item {\ttfamily obj.\-Prevent\-Seam\-Off ()} -\/ Control how the texture coordinates are generated. If Prevent\-Seam is set, the s-\/coordinate ranges from 0-\/$>$1 and 1-\/$>$0 corresponding to the theta angle variation between 0-\/$>$180 and 180-\/$>$0 degrees. Otherwise, the s-\/coordinate ranges from 0-\/$>$1 between 0-\/$>$360 degrees.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkthreshold}{}\section{vtk\-Threshold}\label{vtkgraphics_vtkthreshold}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Threshold is a filter that extracts cells from any dataset type that satisfy a threshold criterion. A cell satisfies the criterion if the scalar value of (every or any) point satisfies the criterion. The criterion can take three forms\-: 1) greater than a particular value; 2) less than a particular value; or 3) between two values. The output of this filter is an unstructured grid.

Note that scalar values are available from the point and cell attribute data. By default, point data is used to obtain scalars, but you can control this behavior. See the Attribute\-Mode ivar below.

By default only the first scalar value is used in the decision. Use the Component\-Mode and Selected\-Component ivars to control this behavior.

To create an instance of class vtk\-Threshold, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkThreshold
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Threshold has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Threshold class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Threshold = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Threshold = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Threshold\-By\-Lower (double lower)} -\/ Criterion is cells whose scalars are less or equal to lower threshold.  
\item {\ttfamily obj.\-Threshold\-By\-Upper (double upper)} -\/ Criterion is cells whose scalars are greater or equal to upper threshold.  
\item {\ttfamily obj.\-Threshold\-Between (double lower, double upper)} -\/ Criterion is cells whose scalars are between lower and upper thresholds (inclusive of the end values).  
\item {\ttfamily double = obj.\-Get\-Upper\-Threshold ()} -\/ Get the Upper and Lower thresholds.  
\item {\ttfamily double = obj.\-Get\-Lower\-Threshold ()} -\/ Get the Upper and Lower thresholds.  
\item {\ttfamily obj.\-Set\-Attribute\-Mode (int )} -\/ Control how the filter works with scalar point data and cell attribute data. By default (Attribute\-Mode\-To\-Default), the filter will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the filter to use point data (Attribute\-Mode\-To\-Use\-Point\-Data) or cell data (Attribute\-Mode\-To\-Use\-Cell\-Data).  
\item {\ttfamily int = obj.\-Get\-Attribute\-Mode ()} -\/ Control how the filter works with scalar point data and cell attribute data. By default (Attribute\-Mode\-To\-Default), the filter will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the filter to use point data (Attribute\-Mode\-To\-Use\-Point\-Data) or cell data (Attribute\-Mode\-To\-Use\-Cell\-Data).  
\item {\ttfamily obj.\-Set\-Attribute\-Mode\-To\-Default ()} -\/ Control how the filter works with scalar point data and cell attribute data. By default (Attribute\-Mode\-To\-Default), the filter will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the filter to use point data (Attribute\-Mode\-To\-Use\-Point\-Data) or cell data (Attribute\-Mode\-To\-Use\-Cell\-Data).  
\item {\ttfamily obj.\-Set\-Attribute\-Mode\-To\-Use\-Point\-Data ()} -\/ Control how the filter works with scalar point data and cell attribute data. By default (Attribute\-Mode\-To\-Default), the filter will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the filter to use point data (Attribute\-Mode\-To\-Use\-Point\-Data) or cell data (Attribute\-Mode\-To\-Use\-Cell\-Data).  
\item {\ttfamily obj.\-Set\-Attribute\-Mode\-To\-Use\-Cell\-Data ()} -\/ Control how the filter works with scalar point data and cell attribute data. By default (Attribute\-Mode\-To\-Default), the filter will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the filter to use point data (Attribute\-Mode\-To\-Use\-Point\-Data) or cell data (Attribute\-Mode\-To\-Use\-Cell\-Data).  
\item {\ttfamily string = obj.\-Get\-Attribute\-Mode\-As\-String ()} -\/ Control how the filter works with scalar point data and cell attribute data. By default (Attribute\-Mode\-To\-Default), the filter will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the filter to use point data (Attribute\-Mode\-To\-Use\-Point\-Data) or cell data (Attribute\-Mode\-To\-Use\-Cell\-Data).  
\item {\ttfamily obj.\-Set\-Component\-Mode (int )} -\/ Control how the decision of in / out is made with multi-\/component data. The choices are to use the selected component (specified in the Selected\-Component ivar), or to look at all components. When looking at all components, the evaluation can pass if all the components satisfy the rule (Use\-All) or if any satisfy is (Use\-Any). The default value is Use\-Selected.  
\item {\ttfamily int = obj.\-Get\-Component\-Mode\-Min\-Value ()} -\/ Control how the decision of in / out is made with multi-\/component data. The choices are to use the selected component (specified in the Selected\-Component ivar), or to look at all components. When looking at all components, the evaluation can pass if all the components satisfy the rule (Use\-All) or if any satisfy is (Use\-Any). The default value is Use\-Selected.  
\item {\ttfamily int = obj.\-Get\-Component\-Mode\-Max\-Value ()} -\/ Control how the decision of in / out is made with multi-\/component data. The choices are to use the selected component (specified in the Selected\-Component ivar), or to look at all components. When looking at all components, the evaluation can pass if all the components satisfy the rule (Use\-All) or if any satisfy is (Use\-Any). The default value is Use\-Selected.  
\item {\ttfamily int = obj.\-Get\-Component\-Mode ()} -\/ Control how the decision of in / out is made with multi-\/component data. The choices are to use the selected component (specified in the Selected\-Component ivar), or to look at all components. When looking at all components, the evaluation can pass if all the components satisfy the rule (Use\-All) or if any satisfy is (Use\-Any). The default value is Use\-Selected.  
\item {\ttfamily obj.\-Set\-Component\-Mode\-To\-Use\-Selected ()} -\/ Control how the decision of in / out is made with multi-\/component data. The choices are to use the selected component (specified in the Selected\-Component ivar), or to look at all components. When looking at all components, the evaluation can pass if all the components satisfy the rule (Use\-All) or if any satisfy is (Use\-Any). The default value is Use\-Selected.  
\item {\ttfamily obj.\-Set\-Component\-Mode\-To\-Use\-All ()} -\/ Control how the decision of in / out is made with multi-\/component data. The choices are to use the selected component (specified in the Selected\-Component ivar), or to look at all components. When looking at all components, the evaluation can pass if all the components satisfy the rule (Use\-All) or if any satisfy is (Use\-Any). The default value is Use\-Selected.  
\item {\ttfamily obj.\-Set\-Component\-Mode\-To\-Use\-Any ()} -\/ Control how the decision of in / out is made with multi-\/component data. The choices are to use the selected component (specified in the Selected\-Component ivar), or to look at all components. When looking at all components, the evaluation can pass if all the components satisfy the rule (Use\-All) or if any satisfy is (Use\-Any). The default value is Use\-Selected.  
\item {\ttfamily string = obj.\-Get\-Component\-Mode\-As\-String ()} -\/ Control how the decision of in / out is made with multi-\/component data. The choices are to use the selected component (specified in the Selected\-Component ivar), or to look at all components. When looking at all components, the evaluation can pass if all the components satisfy the rule (Use\-All) or if any satisfy is (Use\-Any). The default value is Use\-Selected.  
\item {\ttfamily obj.\-Set\-Selected\-Component (int )} -\/ When the component mode is Use\-Selected, this ivar indicated the selected component. The default value is 0.  
\item {\ttfamily int = obj.\-Get\-Selected\-Component\-Min\-Value ()} -\/ When the component mode is Use\-Selected, this ivar indicated the selected component. The default value is 0.  
\item {\ttfamily int = obj.\-Get\-Selected\-Component\-Max\-Value ()} -\/ When the component mode is Use\-Selected, this ivar indicated the selected component. The default value is 0.  
\item {\ttfamily int = obj.\-Get\-Selected\-Component ()} -\/ When the component mode is Use\-Selected, this ivar indicated the selected component. The default value is 0.  
\item {\ttfamily obj.\-Set\-All\-Scalars (int )} -\/ If using scalars from point data, all scalars for all points in a cell must satisfy the threshold criterion if All\-Scalars is set. Otherwise, just a single scalar value satisfying the threshold criterion enables will extract the cell.  
\item {\ttfamily int = obj.\-Get\-All\-Scalars ()} -\/ If using scalars from point data, all scalars for all points in a cell must satisfy the threshold criterion if All\-Scalars is set. Otherwise, just a single scalar value satisfying the threshold criterion enables will extract the cell.  
\item {\ttfamily obj.\-All\-Scalars\-On ()} -\/ If using scalars from point data, all scalars for all points in a cell must satisfy the threshold criterion if All\-Scalars is set. Otherwise, just a single scalar value satisfying the threshold criterion enables will extract the cell.  
\item {\ttfamily obj.\-All\-Scalars\-Off ()} -\/ If using scalars from point data, all scalars for all points in a cell must satisfy the threshold criterion if All\-Scalars is set. Otherwise, just a single scalar value satisfying the threshold criterion enables will extract the cell.  
\item {\ttfamily obj.\-Set\-Points\-Data\-Type\-To\-Double ()} -\/ Set the data type of the output points (See the data types defined in vtk\-Type.\-h). The default data type is float.  
\item {\ttfamily obj.\-Set\-Points\-Data\-Type\-To\-Float ()} -\/ Set the data type of the output points (See the data types defined in vtk\-Type.\-h). The default data type is float.  
\item {\ttfamily obj.\-Set\-Points\-Data\-Type (int )} -\/ Set the data type of the output points (See the data types defined in vtk\-Type.\-h). The default data type is float.  
\item {\ttfamily int = obj.\-Get\-Points\-Data\-Type ()} -\/ Set the data type of the output points (See the data types defined in vtk\-Type.\-h). The default data type is float.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkthresholdpoints}{}\section{vtk\-Threshold\-Points}\label{vtkgraphics_vtkthresholdpoints}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Threshold\-Points is a filter that extracts points from a dataset that satisfy a threshold criterion. The criterion can take three forms\-: 1) greater than a particular value; 2) less than a particular value; or 3) between a particular value. The output of the filter is polygonal data.

To create an instance of class vtk\-Threshold\-Points, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkThresholdPoints
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Threshold\-Points has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Threshold\-Points class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Threshold\-Points = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Threshold\-Points = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Threshold\-By\-Lower (double lower)} -\/ Criterion is cells whose scalars are less or equal to lower threshold.  
\item {\ttfamily obj.\-Threshold\-By\-Upper (double upper)} -\/ Criterion is cells whose scalars are greater or equal to upper threshold.  
\item {\ttfamily obj.\-Threshold\-Between (double lower, double upper)} -\/ Criterion is cells whose scalars are between lower and upper thresholds (inclusive of the end values).  
\item {\ttfamily obj.\-Set\-Upper\-Threshold (double )} -\/ Set/\-Get the upper threshold.  
\item {\ttfamily double = obj.\-Get\-Upper\-Threshold ()} -\/ Set/\-Get the upper threshold.  
\item {\ttfamily obj.\-Set\-Lower\-Threshold (double )} -\/ Set/\-Get the lower threshold.  
\item {\ttfamily double = obj.\-Get\-Lower\-Threshold ()} -\/ Set/\-Get the lower threshold.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkthresholdtexturecoords}{}\section{vtk\-Threshold\-Texture\-Coords}\label{vtkgraphics_vtkthresholdtexturecoords}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Threshold\-Texture\-Coords is a filter that generates texture coordinates for any input dataset type given a threshold criterion. The criterion can take three forms\-: 1) greater than a particular value (Threshold\-By\-Upper()); 2) less than a particular value (Threshold\-By\-Lower(); or 3) between two values (Threshold\-Between(). If the threshold criterion is satisfied, the \char`\"{}in\char`\"{} texture coordinate will be set (this can be specified by the user). If the threshold criterion is not satisfied the \char`\"{}out\char`\"{} is set.

To create an instance of class vtk\-Threshold\-Texture\-Coords, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkThresholdTextureCoords
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Threshold\-Texture\-Coords has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Threshold\-Texture\-Coords class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Threshold\-Texture\-Coords = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Threshold\-Texture\-Coords = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Threshold\-By\-Lower (double lower)} -\/ Criterion is cells whose scalars are less than lower threshold.  
\item {\ttfamily obj.\-Threshold\-By\-Upper (double upper)} -\/ Criterion is cells whose scalars are less than upper threshold.  
\item {\ttfamily obj.\-Threshold\-Between (double lower, double upper)} -\/ Criterion is cells whose scalars are between lower and upper thresholds.  
\item {\ttfamily double = obj.\-Get\-Upper\-Threshold ()} -\/ Return the upper and lower thresholds.  
\item {\ttfamily double = obj.\-Get\-Lower\-Threshold ()} -\/ Return the upper and lower thresholds.  
\item {\ttfamily obj.\-Set\-Texture\-Dimension (int )} -\/ Set the desired dimension of the texture map.  
\item {\ttfamily int = obj.\-Get\-Texture\-Dimension\-Min\-Value ()} -\/ Set the desired dimension of the texture map.  
\item {\ttfamily int = obj.\-Get\-Texture\-Dimension\-Max\-Value ()} -\/ Set the desired dimension of the texture map.  
\item {\ttfamily int = obj.\-Get\-Texture\-Dimension ()} -\/ Set the desired dimension of the texture map.  
\item {\ttfamily obj.\-Set\-In\-Texture\-Coord (double , double , double )} -\/ Set the texture coordinate value for point satisfying threshold criterion.  
\item {\ttfamily obj.\-Set\-In\-Texture\-Coord (double a\mbox{[}3\mbox{]})} -\/ Set the texture coordinate value for point satisfying threshold criterion.  
\item {\ttfamily double = obj. Get\-In\-Texture\-Coord ()} -\/ Set the texture coordinate value for point satisfying threshold criterion.  
\item {\ttfamily obj.\-Set\-Out\-Texture\-Coord (double , double , double )} -\/ Set the texture coordinate value for point N\-O\-T satisfying threshold criterion.  
\item {\ttfamily obj.\-Set\-Out\-Texture\-Coord (double a\mbox{[}3\mbox{]})} -\/ Set the texture coordinate value for point N\-O\-T satisfying threshold criterion.  
\item {\ttfamily double = obj. Get\-Out\-Texture\-Coord ()} -\/ Set the texture coordinate value for point N\-O\-T satisfying threshold criterion.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtktimesourceexample}{}\section{vtk\-Time\-Source\-Example}\label{vtkgraphics_vtktimesourceexample}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Creates a small easily understood time varying data set for testing. The output is a vtk\-Untructured\-Grid in which the point and cell values vary over time in a sin wave. The analytic ivar controls whether the output corresponds to a step function over time or is continuous. The X and Y Amplitude ivars make the output move in the X and Y directions over time. The Growing ivar makes the number of cells in the output grow and then shrink over time.

To create an instance of class vtk\-Time\-Source\-Example, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTimeSourceExample
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Time\-Source\-Example has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Time\-Source\-Example class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Time\-Source\-Example = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Time\-Source\-Example = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Analytic (int )}  
\item {\ttfamily int = obj.\-Get\-Analytic\-Min\-Value ()}  
\item {\ttfamily int = obj.\-Get\-Analytic\-Max\-Value ()}  
\item {\ttfamily int = obj.\-Get\-Analytic ()}  
\item {\ttfamily obj.\-Analytic\-On ()}  
\item {\ttfamily obj.\-Analytic\-Off ()}  
\item {\ttfamily obj.\-Set\-X\-Amplitude (double )}  
\item {\ttfamily double = obj.\-Get\-X\-Amplitude ()}  
\item {\ttfamily obj.\-Set\-Y\-Amplitude (double )}  
\item {\ttfamily double = obj.\-Get\-Y\-Amplitude ()}  
\item {\ttfamily obj.\-Set\-Growing (int )}  
\item {\ttfamily int = obj.\-Get\-Growing\-Min\-Value ()}  
\item {\ttfamily int = obj.\-Get\-Growing\-Max\-Value ()}  
\item {\ttfamily int = obj.\-Get\-Growing ()}  
\item {\ttfamily obj.\-Growing\-On ()}  
\item {\ttfamily obj.\-Growing\-Off ()}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtktransformcoordinatesystems}{}\section{vtk\-Transform\-Coordinate\-Systems}\label{vtkgraphics_vtktransformcoordinatesystems}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This filter transforms points from one coordinate system to another. The user must specify the coordinate systems in which the input and output are specified. The user must also specify the V\-T\-K viewport (i.\-e., renderer) in which the transformation occurs.

To create an instance of class vtk\-Transform\-Coordinate\-Systems, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTransformCoordinateSystems
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Transform\-Coordinate\-Systems has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Transform\-Coordinate\-Systems class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for type information and printing.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for type information and printing.  
\item {\ttfamily vtk\-Transform\-Coordinate\-Systems = obj.\-New\-Instance ()} -\/ Standard methods for type information and printing.  
\item {\ttfamily vtk\-Transform\-Coordinate\-Systems = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for type information and printing.  
\item {\ttfamily obj.\-Set\-Input\-Coordinate\-System (int )} -\/ Set/get the coordinate system in which the input is specified. The current options are World, Viewport, and Display. By default the input coordinate system is World.  
\item {\ttfamily int = obj.\-Get\-Input\-Coordinate\-System ()} -\/ Set/get the coordinate system in which the input is specified. The current options are World, Viewport, and Display. By default the input coordinate system is World.  
\item {\ttfamily obj.\-Set\-Input\-Coordinate\-System\-To\-Display ()} -\/ Set/get the coordinate system in which the input is specified. The current options are World, Viewport, and Display. By default the input coordinate system is World.  
\item {\ttfamily obj.\-Set\-Input\-Coordinate\-System\-To\-Viewport ()} -\/ Set/get the coordinate system in which the input is specified. The current options are World, Viewport, and Display. By default the input coordinate system is World.  
\item {\ttfamily obj.\-Set\-Input\-Coordinate\-System\-To\-World ()} -\/ Set/get the coordinate system to which to transform the output. The current options are World, Viewport, and Display. By default the output coordinate system is Display.  
\item {\ttfamily obj.\-Set\-Output\-Coordinate\-System (int )} -\/ Set/get the coordinate system to which to transform the output. The current options are World, Viewport, and Display. By default the output coordinate system is Display.  
\item {\ttfamily int = obj.\-Get\-Output\-Coordinate\-System ()} -\/ Set/get the coordinate system to which to transform the output. The current options are World, Viewport, and Display. By default the output coordinate system is Display.  
\item {\ttfamily obj.\-Set\-Output\-Coordinate\-System\-To\-Display ()} -\/ Set/get the coordinate system to which to transform the output. The current options are World, Viewport, and Display. By default the output coordinate system is Display.  
\item {\ttfamily obj.\-Set\-Output\-Coordinate\-System\-To\-Viewport ()} -\/ Set/get the coordinate system to which to transform the output. The current options are World, Viewport, and Display. By default the output coordinate system is Display.  
\item {\ttfamily obj.\-Set\-Output\-Coordinate\-System\-To\-World ()} -\/ Return the M\-Time also considering the instance of vtk\-Coordinate.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return the M\-Time also considering the instance of vtk\-Coordinate.  
\item {\ttfamily obj.\-Set\-Viewport (vtk\-Viewport viewport)} -\/ In order for successful coordinate transformation to occur, an instance of vtk\-Viewport (e.\-g., a V\-T\-K renderer) must be specified. N\-O\-T\-E\-: this is a raw pointer, not a weak pointer not a reference counted object to avoid reference cycle loop between rendering classes and filter classes.  
\item {\ttfamily vtk\-Viewport = obj.\-Get\-Viewport ()} -\/ In order for successful coordinate transformation to occur, an instance of vtk\-Viewport (e.\-g., a V\-T\-K renderer) must be specified. N\-O\-T\-E\-: this is a raw pointer, not a weak pointer not a reference counted object to avoid reference cycle loop between rendering classes and filter classes.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtktransformfilter}{}\section{vtk\-Transform\-Filter}\label{vtkgraphics_vtktransformfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Transform\-Filter is a filter to transform point coordinates, and associated point normals and vectors. Other point data is passed through the filter.

An alternative method of transformation is to use vtk\-Actor's methods to scale, rotate, and translate objects. The difference between the two methods is that vtk\-Actor's transformation simply effects where objects are rendered (via the graphics pipeline), whereas vtk\-Transform\-Filter actually modifies point coordinates in the visualization pipeline. This is necessary for some objects (e.\-g., vtk\-Probe\-Filter) that require point coordinates as input.

To create an instance of class vtk\-Transform\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTransformFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Transform\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Transform\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Transform\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Transform\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return the M\-Time also considering the transform.  
\item {\ttfamily obj.\-Set\-Transform (vtk\-Abstract\-Transform )} -\/ Specify the transform object used to transform points.  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Get\-Transform ()} -\/ Specify the transform object used to transform points.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtktransformpolydatafilter}{}\section{vtk\-Transform\-Poly\-Data\-Filter}\label{vtkgraphics_vtktransformpolydatafilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Transform\-Poly\-Data\-Filter is a filter to transform point coordinates and associated point and cell normals and vectors. Other point and cell data is passed through the filter unchanged. This filter is specialized for polygonal data. See vtk\-Transform\-Filter for more general data.

An alternative method of transformation is to use vtk\-Actor's methods to scale, rotate, and translate objects. The difference between the two methods is that vtk\-Actor's transformation simply effects where objects are rendered (via the graphics pipeline), whereas vtk\-Transform\-Poly\-Data\-Filter actually modifies point coordinates in the visualization pipeline. This is necessary for some objects (e.\-g., vtk\-Probe\-Filter) that require point coordinates as input.

To create an instance of class vtk\-Transform\-Poly\-Data\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTransformPolyDataFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Transform\-Poly\-Data\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Transform\-Poly\-Data\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Transform\-Poly\-Data\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Transform\-Poly\-Data\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return the M\-Time also considering the transform.  
\item {\ttfamily obj.\-Set\-Transform (vtk\-Abstract\-Transform )} -\/ Specify the transform object used to transform points.  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Get\-Transform ()} -\/ Specify the transform object used to transform points.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtktransformtexturecoords}{}\section{vtk\-Transform\-Texture\-Coords}\label{vtkgraphics_vtktransformtexturecoords}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Transform\-Texture\-Coords is a filter that operates on texture coordinates. It ingests any type of dataset, and outputs a dataset of the same type. The filter lets you scale, translate, and rotate texture coordinates. For example, by using the the Scale ivar, you can shift texture coordinates that range from (0-\/$>$1) to range from (0-\/$>$10) (useful for repeated patterns).

The filter operates on texture coordinates of dimension 1-\/$>$3. The texture coordinates are referred to as r-\/s-\/t. If the texture map is two dimensional, the t-\/coordinate (and operations on the t-\/coordinate) are ignored.

To create an instance of class vtk\-Transform\-Texture\-Coords, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTransformTextureCoords
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Transform\-Texture\-Coords has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Transform\-Texture\-Coords class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Transform\-Texture\-Coords = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Transform\-Texture\-Coords = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Position (double , double , double )} -\/ Set/\-Get the position of the texture map. Setting the position translates the texture map by the amount specified.  
\item {\ttfamily obj.\-Set\-Position (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of the texture map. Setting the position translates the texture map by the amount specified.  
\item {\ttfamily double = obj. Get\-Position ()} -\/ Set/\-Get the position of the texture map. Setting the position translates the texture map by the amount specified.  
\item {\ttfamily obj.\-Add\-Position (double delta\-R, double delta\-S, double delta\-T)} -\/ Incrementally change the position of the texture map (i.\-e., does a translate or shift of the texture coordinates).  
\item {\ttfamily obj.\-Add\-Position (double delta\-Position\mbox{[}3\mbox{]})} -\/ Incrementally change the position of the texture map (i.\-e., does a translate or shift of the texture coordinates).  
\item {\ttfamily obj.\-Set\-Scale (double , double , double )} -\/ Set/\-Get the scale of the texture map. Scaling in performed independently on the r, s and t axes.  
\item {\ttfamily obj.\-Set\-Scale (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the scale of the texture map. Scaling in performed independently on the r, s and t axes.  
\item {\ttfamily double = obj. Get\-Scale ()} -\/ Set/\-Get the scale of the texture map. Scaling in performed independently on the r, s and t axes.  
\item {\ttfamily obj.\-Set\-Origin (double , double , double )} -\/ Set/\-Get the origin of the texture map. This is the point about which the texture map is flipped (e.\-g., rotated). Since a typical texture map ranges from (0,1) in the r-\/s-\/t coordinates, the default origin is set at (0.\-5,0.\-5,0.\-5).  
\item {\ttfamily obj.\-Set\-Origin (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the origin of the texture map. This is the point about which the texture map is flipped (e.\-g., rotated). Since a typical texture map ranges from (0,1) in the r-\/s-\/t coordinates, the default origin is set at (0.\-5,0.\-5,0.\-5).  
\item {\ttfamily double = obj. Get\-Origin ()} -\/ Set/\-Get the origin of the texture map. This is the point about which the texture map is flipped (e.\-g., rotated). Since a typical texture map ranges from (0,1) in the r-\/s-\/t coordinates, the default origin is set at (0.\-5,0.\-5,0.\-5).  
\item {\ttfamily obj.\-Set\-Flip\-R (int )} -\/ Boolean indicates whether the texture map should be flipped around the s-\/axis. Note that the flips occur around the texture origin.  
\item {\ttfamily int = obj.\-Get\-Flip\-R ()} -\/ Boolean indicates whether the texture map should be flipped around the s-\/axis. Note that the flips occur around the texture origin.  
\item {\ttfamily obj.\-Flip\-R\-On ()} -\/ Boolean indicates whether the texture map should be flipped around the s-\/axis. Note that the flips occur around the texture origin.  
\item {\ttfamily obj.\-Flip\-R\-Off ()} -\/ Boolean indicates whether the texture map should be flipped around the s-\/axis. Note that the flips occur around the texture origin.  
\item {\ttfamily obj.\-Set\-Flip\-S (int )} -\/ Boolean indicates whether the texture map should be flipped around the s-\/axis. Note that the flips occur around the texture origin.  
\item {\ttfamily int = obj.\-Get\-Flip\-S ()} -\/ Boolean indicates whether the texture map should be flipped around the s-\/axis. Note that the flips occur around the texture origin.  
\item {\ttfamily obj.\-Flip\-S\-On ()} -\/ Boolean indicates whether the texture map should be flipped around the s-\/axis. Note that the flips occur around the texture origin.  
\item {\ttfamily obj.\-Flip\-S\-Off ()} -\/ Boolean indicates whether the texture map should be flipped around the s-\/axis. Note that the flips occur around the texture origin.  
\item {\ttfamily obj.\-Set\-Flip\-T (int )} -\/ Boolean indicates whether the texture map should be flipped around the t-\/axis. Note that the flips occur around the texture origin.  
\item {\ttfamily int = obj.\-Get\-Flip\-T ()} -\/ Boolean indicates whether the texture map should be flipped around the t-\/axis. Note that the flips occur around the texture origin.  
\item {\ttfamily obj.\-Flip\-T\-On ()} -\/ Boolean indicates whether the texture map should be flipped around the t-\/axis. Note that the flips occur around the texture origin.  
\item {\ttfamily obj.\-Flip\-T\-Off ()} -\/ Boolean indicates whether the texture map should be flipped around the t-\/axis. Note that the flips occur around the texture origin.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtktrianglefilter}{}\section{vtk\-Triangle\-Filter}\label{vtkgraphics_vtktrianglefilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Triangle\-Filter generates triangles from input polygons and triangle strips. The filter also will pass through vertices and lines, if requested.

To create an instance of class vtk\-Triangle\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTriangleFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Triangle\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Triangle\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Triangle\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Triangle\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Pass\-Verts\-On ()} -\/ Turn on/off passing vertices through filter.  
\item {\ttfamily obj.\-Pass\-Verts\-Off ()} -\/ Turn on/off passing vertices through filter.  
\item {\ttfamily obj.\-Set\-Pass\-Verts (int )} -\/ Turn on/off passing vertices through filter.  
\item {\ttfamily int = obj.\-Get\-Pass\-Verts ()} -\/ Turn on/off passing vertices through filter.  
\item {\ttfamily obj.\-Pass\-Lines\-On ()} -\/ Turn on/off passing lines through filter.  
\item {\ttfamily obj.\-Pass\-Lines\-Off ()} -\/ Turn on/off passing lines through filter.  
\item {\ttfamily obj.\-Set\-Pass\-Lines (int )} -\/ Turn on/off passing lines through filter.  
\item {\ttfamily int = obj.\-Get\-Pass\-Lines ()} -\/ Turn on/off passing lines through filter.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtktriangulartcoords}{}\section{vtk\-Triangular\-T\-Coords}\label{vtkgraphics_vtktriangulartcoords}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Triangular\-T\-Coords is a filter that generates texture coordinates for triangles. Texture coordinates for each triangle are\-: (0,0), (1,0) and (.5,sqrt(3)/2). This filter assumes that the triangle texture map is symmetric about the center of the triangle. Thus the order Of the texture coordinates is not important. The procedural texture in vtk\-Triangular\-Texture is designed with this symmetry. For more information see the paper \char`\"{}\-Opacity-\/modulating Triangular Textures for Irregular 
 Surfaces,\char`\"{} by Penny Rheingans, I\-E\-E\-E Visualization '96, pp. 219-\/225.

To create an instance of class vtk\-Triangular\-T\-Coords, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTriangularTCoords
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Triangular\-T\-Coords has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Triangular\-T\-Coords class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Triangular\-T\-Coords = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Triangular\-T\-Coords = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtktubefilter}{}\section{vtk\-Tube\-Filter}\label{vtkgraphics_vtktubefilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Tube\-Filter is a filter that generates a tube around each input line. The tubes are made up of triangle strips and rotate around the tube with the rotation of the line normals. (If no normals are present, they are computed automatically.) The radius of the tube can be set to vary with scalar or vector value. If the radius varies with scalar value the radius is linearly adjusted. If the radius varies with vector value, a mass flux preserving variation is used. The number of sides for the tube also can be specified. You can also specify which of the sides are visible. This is useful for generating interesting striping effects. Other options include the ability to cap the tube and generate texture coordinates. Texture coordinates can be used with an associated texture map to create interesting effects such as marking the tube with stripes corresponding to length or time.

This filter is typically used to create thick or dramatic lines. Another common use is to combine this filter with vtk\-Stream\-Line to generate streamtubes.

To create an instance of class vtk\-Tube\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTubeFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Tube\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Tube\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Tube\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Tube\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Radius (double )} -\/ Set the minimum tube radius (minimum because the tube radius may vary).  
\item {\ttfamily double = obj.\-Get\-Radius\-Min\-Value ()} -\/ Set the minimum tube radius (minimum because the tube radius may vary).  
\item {\ttfamily double = obj.\-Get\-Radius\-Max\-Value ()} -\/ Set the minimum tube radius (minimum because the tube radius may vary).  
\item {\ttfamily double = obj.\-Get\-Radius ()} -\/ Set the minimum tube radius (minimum because the tube radius may vary).  
\item {\ttfamily obj.\-Set\-Vary\-Radius (int )} -\/ Turn on/off the variation of tube radius with scalar value.  
\item {\ttfamily int = obj.\-Get\-Vary\-Radius\-Min\-Value ()} -\/ Turn on/off the variation of tube radius with scalar value.  
\item {\ttfamily int = obj.\-Get\-Vary\-Radius\-Max\-Value ()} -\/ Turn on/off the variation of tube radius with scalar value.  
\item {\ttfamily int = obj.\-Get\-Vary\-Radius ()} -\/ Turn on/off the variation of tube radius with scalar value.  
\item {\ttfamily obj.\-Set\-Vary\-Radius\-To\-Vary\-Radius\-Off ()} -\/ Turn on/off the variation of tube radius with scalar value.  
\item {\ttfamily obj.\-Set\-Vary\-Radius\-To\-Vary\-Radius\-By\-Scalar ()} -\/ Turn on/off the variation of tube radius with scalar value.  
\item {\ttfamily obj.\-Set\-Vary\-Radius\-To\-Vary\-Radius\-By\-Vector ()} -\/ Turn on/off the variation of tube radius with scalar value.  
\item {\ttfamily obj.\-Set\-Vary\-Radius\-To\-Vary\-Radius\-By\-Absolute\-Scalar ()} -\/ Turn on/off the variation of tube radius with scalar value.  
\item {\ttfamily string = obj.\-Get\-Vary\-Radius\-As\-String ()} -\/ Turn on/off the variation of tube radius with scalar value.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Sides (int )} -\/ Set the number of sides for the tube. At a minimum, number of sides is 3.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Sides\-Min\-Value ()} -\/ Set the number of sides for the tube. At a minimum, number of sides is 3.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Sides\-Max\-Value ()} -\/ Set the number of sides for the tube. At a minimum, number of sides is 3.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Sides ()} -\/ Set the number of sides for the tube. At a minimum, number of sides is 3.  
\item {\ttfamily obj.\-Set\-Radius\-Factor (double )} -\/ Set the maximum tube radius in terms of a multiple of the minimum radius.  
\item {\ttfamily double = obj.\-Get\-Radius\-Factor ()} -\/ Set the maximum tube radius in terms of a multiple of the minimum radius.  
\item {\ttfamily obj.\-Set\-Default\-Normal (double , double , double )} -\/ Set the default normal to use if no normals are supplied, and the Default\-Normal\-On is set.  
\item {\ttfamily obj.\-Set\-Default\-Normal (double a\mbox{[}3\mbox{]})} -\/ Set the default normal to use if no normals are supplied, and the Default\-Normal\-On is set.  
\item {\ttfamily double = obj. Get\-Default\-Normal ()} -\/ Set the default normal to use if no normals are supplied, and the Default\-Normal\-On is set.  
\item {\ttfamily obj.\-Set\-Use\-Default\-Normal (int )} -\/ Set a boolean to control whether to use default normals. Default\-Normal\-On is set.  
\item {\ttfamily int = obj.\-Get\-Use\-Default\-Normal ()} -\/ Set a boolean to control whether to use default normals. Default\-Normal\-On is set.  
\item {\ttfamily obj.\-Use\-Default\-Normal\-On ()} -\/ Set a boolean to control whether to use default normals. Default\-Normal\-On is set.  
\item {\ttfamily obj.\-Use\-Default\-Normal\-Off ()} -\/ Set a boolean to control whether to use default normals. Default\-Normal\-On is set.  
\item {\ttfamily obj.\-Set\-Sides\-Share\-Vertices (int )} -\/ Set a boolean to control whether tube sides should share vertices. This creates independent strips, with constant normals so the tube is always faceted in appearance.  
\item {\ttfamily int = obj.\-Get\-Sides\-Share\-Vertices ()} -\/ Set a boolean to control whether tube sides should share vertices. This creates independent strips, with constant normals so the tube is always faceted in appearance.  
\item {\ttfamily obj.\-Sides\-Share\-Vertices\-On ()} -\/ Set a boolean to control whether tube sides should share vertices. This creates independent strips, with constant normals so the tube is always faceted in appearance.  
\item {\ttfamily obj.\-Sides\-Share\-Vertices\-Off ()} -\/ Set a boolean to control whether tube sides should share vertices. This creates independent strips, with constant normals so the tube is always faceted in appearance.  
\item {\ttfamily obj.\-Set\-Capping (int )} -\/ Turn on/off whether to cap the ends with polygons.  
\item {\ttfamily int = obj.\-Get\-Capping ()} -\/ Turn on/off whether to cap the ends with polygons.  
\item {\ttfamily obj.\-Capping\-On ()} -\/ Turn on/off whether to cap the ends with polygons.  
\item {\ttfamily obj.\-Capping\-Off ()} -\/ Turn on/off whether to cap the ends with polygons.  
\item {\ttfamily obj.\-Set\-On\-Ratio (int )} -\/ Control the striping of the tubes. If On\-Ratio is greater than 1, then every nth tube side is turned on, beginning with the Offset side.  
\item {\ttfamily int = obj.\-Get\-On\-Ratio\-Min\-Value ()} -\/ Control the striping of the tubes. If On\-Ratio is greater than 1, then every nth tube side is turned on, beginning with the Offset side.  
\item {\ttfamily int = obj.\-Get\-On\-Ratio\-Max\-Value ()} -\/ Control the striping of the tubes. If On\-Ratio is greater than 1, then every nth tube side is turned on, beginning with the Offset side.  
\item {\ttfamily int = obj.\-Get\-On\-Ratio ()} -\/ Control the striping of the tubes. If On\-Ratio is greater than 1, then every nth tube side is turned on, beginning with the Offset side.  
\item {\ttfamily obj.\-Set\-Offset (int )} -\/ Control the striping of the tubes. The offset sets the first tube side that is visible. Offset is generally used with On\-Ratio to create nifty striping effects.  
\item {\ttfamily int = obj.\-Get\-Offset\-Min\-Value ()} -\/ Control the striping of the tubes. The offset sets the first tube side that is visible. Offset is generally used with On\-Ratio to create nifty striping effects.  
\item {\ttfamily int = obj.\-Get\-Offset\-Max\-Value ()} -\/ Control the striping of the tubes. The offset sets the first tube side that is visible. Offset is generally used with On\-Ratio to create nifty striping effects.  
\item {\ttfamily int = obj.\-Get\-Offset ()} -\/ Control the striping of the tubes. The offset sets the first tube side that is visible. Offset is generally used with On\-Ratio to create nifty striping effects.  
\item {\ttfamily obj.\-Set\-Generate\-T\-Coords (int )} -\/ Control whether and how texture coordinates are produced. This is useful for striping the tube with length textures, etc. If you use scalars to create the texture, the scalars are assumed to be monotonically increasing (or decreasing).  
\item {\ttfamily int = obj.\-Get\-Generate\-T\-Coords\-Min\-Value ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the tube with length textures, etc. If you use scalars to create the texture, the scalars are assumed to be monotonically increasing (or decreasing).  
\item {\ttfamily int = obj.\-Get\-Generate\-T\-Coords\-Max\-Value ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the tube with length textures, etc. If you use scalars to create the texture, the scalars are assumed to be monotonically increasing (or decreasing).  
\item {\ttfamily int = obj.\-Get\-Generate\-T\-Coords ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the tube with length textures, etc. If you use scalars to create the texture, the scalars are assumed to be monotonically increasing (or decreasing).  
\item {\ttfamily obj.\-Set\-Generate\-T\-Coords\-To\-Off ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the tube with length textures, etc. If you use scalars to create the texture, the scalars are assumed to be monotonically increasing (or decreasing).  
\item {\ttfamily obj.\-Set\-Generate\-T\-Coords\-To\-Normalized\-Length ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the tube with length textures, etc. If you use scalars to create the texture, the scalars are assumed to be monotonically increasing (or decreasing).  
\item {\ttfamily obj.\-Set\-Generate\-T\-Coords\-To\-Use\-Length ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the tube with length textures, etc. If you use scalars to create the texture, the scalars are assumed to be monotonically increasing (or decreasing).  
\item {\ttfamily obj.\-Set\-Generate\-T\-Coords\-To\-Use\-Scalars ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the tube with length textures, etc. If you use scalars to create the texture, the scalars are assumed to be monotonically increasing (or decreasing).  
\item {\ttfamily string = obj.\-Get\-Generate\-T\-Coords\-As\-String ()} -\/ Control whether and how texture coordinates are produced. This is useful for striping the tube with length textures, etc. If you use scalars to create the texture, the scalars are assumed to be monotonically increasing (or decreasing).  
\item {\ttfamily obj.\-Set\-Texture\-Length (double )} -\/ Control the conversion of units during the texture coordinates calculation. The Texture\-Length indicates what length (whether calculated from scalars or length) is mapped to the \mbox{[}0,1) texture space.  
\item {\ttfamily double = obj.\-Get\-Texture\-Length\-Min\-Value ()} -\/ Control the conversion of units during the texture coordinates calculation. The Texture\-Length indicates what length (whether calculated from scalars or length) is mapped to the \mbox{[}0,1) texture space.  
\item {\ttfamily double = obj.\-Get\-Texture\-Length\-Max\-Value ()} -\/ Control the conversion of units during the texture coordinates calculation. The Texture\-Length indicates what length (whether calculated from scalars or length) is mapped to the \mbox{[}0,1) texture space.  
\item {\ttfamily double = obj.\-Get\-Texture\-Length ()} -\/ Control the conversion of units during the texture coordinates calculation. The Texture\-Length indicates what length (whether calculated from scalars or length) is mapped to the \mbox{[}0,1) texture space.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkuncertaintytubefilter}{}\section{vtk\-Uncertainty\-Tube\-Filter}\label{vtkgraphics_vtkuncertaintytubefilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Uncertainty\-Tube\-Filter is a filter that generates ellipsoidal (in cross section) tubes that follows a polyline. The input is a vtk\-Poly\-Data with polylines that have associated vector point data. The vector data represents the uncertainty of the polyline in the x-\/y-\/z directions.

To create an instance of class vtk\-Uncertainty\-Tube\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkUncertaintyTubeFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Uncertainty\-Tube\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Uncertainty\-Tube\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for printing and obtaining type information for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for printing and obtaining type information for instances of this class.  
\item {\ttfamily vtk\-Uncertainty\-Tube\-Filter = obj.\-New\-Instance ()} -\/ Standard methods for printing and obtaining type information for instances of this class.  
\item {\ttfamily vtk\-Uncertainty\-Tube\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for printing and obtaining type information for instances of this class.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Sides (int )} -\/ Set / get the number of sides for the tube. At a minimum, the number of sides is 3.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Sides\-Min\-Value ()} -\/ Set / get the number of sides for the tube. At a minimum, the number of sides is 3.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Sides\-Max\-Value ()} -\/ Set / get the number of sides for the tube. At a minimum, the number of sides is 3.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Sides ()} -\/ Set / get the number of sides for the tube. At a minimum, the number of sides is 3.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkunstructuredgridgeometryfilter}{}\section{vtk\-Unstructured\-Grid\-Geometry\-Filter}\label{vtkgraphics_vtkunstructuredgridgeometryfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Unstructured\-Grid\-Geometry\-Filter is a filter that extracts geometry (and associated data) from an unstructured grid. It differs from vtk\-Geometry\-Filter by not tessellating higher order faces\-: 2\-D faces of quadratic 3\-D cells will be quadratic. A quadratic edge is extracted as a quadratic edge. For that purpose, the output of this filter is an unstructured grid, not a polydata. Also, the face of a voxel is a pixel, not a quad. Geometry is obtained as follows\-: all 0\-D, 1\-D, and 2\-D cells are extracted. All 2\-D faces that are used by only one 3\-D cell (i.\-e., boundary faces) are extracted. It also is possible to specify conditions on point ids, cell ids, and on bounding box (referred to as \char`\"{}\-Extent\char`\"{}) to control the extraction process.

To create an instance of class vtk\-Unstructured\-Grid\-Geometry\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkUnstructuredGridGeometryFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Unstructured\-Grid\-Geometry\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Geometry\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Geometry\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Geometry\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Point\-Clipping (int )} -\/ Turn on/off selection of geometry by point id.  
\item {\ttfamily int = obj.\-Get\-Point\-Clipping ()} -\/ Turn on/off selection of geometry by point id.  
\item {\ttfamily obj.\-Point\-Clipping\-On ()} -\/ Turn on/off selection of geometry by point id.  
\item {\ttfamily obj.\-Point\-Clipping\-Off ()} -\/ Turn on/off selection of geometry by point id.  
\item {\ttfamily obj.\-Set\-Cell\-Clipping (int )} -\/ Turn on/off selection of geometry by cell id.  
\item {\ttfamily int = obj.\-Get\-Cell\-Clipping ()} -\/ Turn on/off selection of geometry by cell id.  
\item {\ttfamily obj.\-Cell\-Clipping\-On ()} -\/ Turn on/off selection of geometry by cell id.  
\item {\ttfamily obj.\-Cell\-Clipping\-Off ()} -\/ Turn on/off selection of geometry by cell id.  
\item {\ttfamily obj.\-Set\-Extent\-Clipping (int )} -\/ Turn on/off selection of geometry via bounding box.  
\item {\ttfamily int = obj.\-Get\-Extent\-Clipping ()} -\/ Turn on/off selection of geometry via bounding box.  
\item {\ttfamily obj.\-Extent\-Clipping\-On ()} -\/ Turn on/off selection of geometry via bounding box.  
\item {\ttfamily obj.\-Extent\-Clipping\-Off ()} -\/ Turn on/off selection of geometry via bounding box.  
\item {\ttfamily obj.\-Set\-Point\-Minimum (vtk\-Id\-Type )} -\/ Specify the minimum point id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Point\-Minimum\-Min\-Value ()} -\/ Specify the minimum point id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Point\-Minimum\-Max\-Value ()} -\/ Specify the minimum point id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Point\-Minimum ()} -\/ Specify the minimum point id for point id selection.  
\item {\ttfamily obj.\-Set\-Point\-Maximum (vtk\-Id\-Type )} -\/ Specify the maximum point id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Point\-Maximum\-Min\-Value ()} -\/ Specify the maximum point id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Point\-Maximum\-Max\-Value ()} -\/ Specify the maximum point id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Point\-Maximum ()} -\/ Specify the maximum point id for point id selection.  
\item {\ttfamily obj.\-Set\-Cell\-Minimum (vtk\-Id\-Type )} -\/ Specify the minimum cell id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Cell\-Minimum\-Min\-Value ()} -\/ Specify the minimum cell id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Cell\-Minimum\-Max\-Value ()} -\/ Specify the minimum cell id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Cell\-Minimum ()} -\/ Specify the minimum cell id for point id selection.  
\item {\ttfamily obj.\-Set\-Cell\-Maximum (vtk\-Id\-Type )} -\/ Specify the maximum cell id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Cell\-Maximum\-Min\-Value ()} -\/ Specify the maximum cell id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Cell\-Maximum\-Max\-Value ()} -\/ Specify the maximum cell id for point id selection.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Cell\-Maximum ()} -\/ Specify the maximum cell id for point id selection.  
\item {\ttfamily obj.\-Set\-Extent (double x\-Min, double x\-Max, double y\-Min, double y\-Max, double z\-Min, double z\-Max)} -\/ Specify a (xmin,xmax, ymin,ymax, zmin,zmax) bounding box to clip data.  
\item {\ttfamily obj.\-Set\-Extent (double extent\mbox{[}6\mbox{]})} -\/ Set / get a (xmin,xmax, ymin,ymax, zmin,zmax) bounding box to clip data.  
\item {\ttfamily obj.\-Set\-Merging (int )} -\/ Turn on/off merging of coincident points. Note that is merging is on, points with different point attributes (e.\-g., normals) are merged, which may cause rendering artifacts.  
\item {\ttfamily int = obj.\-Get\-Merging ()} -\/ Turn on/off merging of coincident points. Note that is merging is on, points with different point attributes (e.\-g., normals) are merged, which may cause rendering artifacts.  
\item {\ttfamily obj.\-Merging\-On ()} -\/ Turn on/off merging of coincident points. Note that is merging is on, points with different point attributes (e.\-g., normals) are merged, which may cause rendering artifacts.  
\item {\ttfamily obj.\-Merging\-Off ()} -\/ Turn on/off merging of coincident points. Note that is merging is on, points with different point attributes (e.\-g., normals) are merged, which may cause rendering artifacts.  
\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 M\-Time also considering the locator.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkvectordot}{}\section{vtk\-Vector\-Dot}\label{vtkgraphics_vtkvectordot}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Vector\-Dot is a filter to generate scalar values from a dataset. The scalar value at a point is created by computing the dot product between the normal and vector at that point. Combined with the appropriate color map, this can show nodal lines/mode shapes of vibration, or a displacement plot.

To create an instance of class vtk\-Vector\-Dot, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVectorDot
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Vector\-Dot has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Vector\-Dot class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Vector\-Dot = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Vector\-Dot = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Scalar\-Range (double , double )} -\/ Specify range to map scalars into.  
\item {\ttfamily obj.\-Set\-Scalar\-Range (double a\mbox{[}2\mbox{]})} -\/ Specify range to map scalars into.  
\item {\ttfamily double = obj. Get\-Scalar\-Range ()} -\/ Get the range that scalars map into.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkvectornorm}{}\section{vtk\-Vector\-Norm}\label{vtkgraphics_vtkvectornorm}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Vector\-Norm is a filter that generates scalar values by computing Euclidean norm of vector triplets. Scalars can be normalized 0$<$=s$<$=1 if desired.

Note that this filter operates on point or cell attribute data, or both. By default, the filter operates on both point and cell data if vector point and cell data, respectively, are available from the input. Alternatively, you can choose to generate scalar norm values for just cell or point data.

To create an instance of class vtk\-Vector\-Norm, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVectorNorm
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Vector\-Norm has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Vector\-Norm class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Vector\-Norm = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Vector\-Norm = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Normalize (int )} -\/ Specify whether to normalize scalar values.  
\item {\ttfamily int = obj.\-Get\-Normalize ()} -\/ Specify whether to normalize scalar values.  
\item {\ttfamily obj.\-Normalize\-On ()} -\/ Specify whether to normalize scalar values.  
\item {\ttfamily obj.\-Normalize\-Off ()} -\/ Specify whether to normalize scalar values.  
\item {\ttfamily obj.\-Set\-Attribute\-Mode (int )} -\/ Control how the filter works to generate scalar data from the input vector data. By default, (Attribute\-Mode\-To\-Default) the filter will generate the scalar norm for point and cell data (if vector data present in the input). Alternatively, you can explicitly set the filter to generate point data (Attribute\-Mode\-To\-Use\-Point\-Data) or cell data (Attribute\-Mode\-To\-Use\-Cell\-Data).  
\item {\ttfamily int = obj.\-Get\-Attribute\-Mode ()} -\/ Control how the filter works to generate scalar data from the input vector data. By default, (Attribute\-Mode\-To\-Default) the filter will generate the scalar norm for point and cell data (if vector data present in the input). Alternatively, you can explicitly set the filter to generate point data (Attribute\-Mode\-To\-Use\-Point\-Data) or cell data (Attribute\-Mode\-To\-Use\-Cell\-Data).  
\item {\ttfamily obj.\-Set\-Attribute\-Mode\-To\-Default ()} -\/ Control how the filter works to generate scalar data from the input vector data. By default, (Attribute\-Mode\-To\-Default) the filter will generate the scalar norm for point and cell data (if vector data present in the input). Alternatively, you can explicitly set the filter to generate point data (Attribute\-Mode\-To\-Use\-Point\-Data) or cell data (Attribute\-Mode\-To\-Use\-Cell\-Data).  
\item {\ttfamily obj.\-Set\-Attribute\-Mode\-To\-Use\-Point\-Data ()} -\/ Control how the filter works to generate scalar data from the input vector data. By default, (Attribute\-Mode\-To\-Default) the filter will generate the scalar norm for point and cell data (if vector data present in the input). Alternatively, you can explicitly set the filter to generate point data (Attribute\-Mode\-To\-Use\-Point\-Data) or cell data (Attribute\-Mode\-To\-Use\-Cell\-Data).  
\item {\ttfamily obj.\-Set\-Attribute\-Mode\-To\-Use\-Cell\-Data ()} -\/ Control how the filter works to generate scalar data from the input vector data. By default, (Attribute\-Mode\-To\-Default) the filter will generate the scalar norm for point and cell data (if vector data present in the input). Alternatively, you can explicitly set the filter to generate point data (Attribute\-Mode\-To\-Use\-Point\-Data) or cell data (Attribute\-Mode\-To\-Use\-Cell\-Data).  
\item {\ttfamily string = obj.\-Get\-Attribute\-Mode\-As\-String ()} -\/ Control how the filter works to generate scalar data from the input vector data. By default, (Attribute\-Mode\-To\-Default) the filter will generate the scalar norm for point and cell data (if vector data present in the input). Alternatively, you can explicitly set the filter to generate point data (Attribute\-Mode\-To\-Use\-Point\-Data) or cell data (Attribute\-Mode\-To\-Use\-Cell\-Data).  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkvertexglyphfilter}{}\section{vtk\-Vertex\-Glyph\-Filter}\label{vtkgraphics_vtkvertexglyphfilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This filter throws away all of the cells in the input and replaces them with a vertex on each point. The intended use of this filter is roughly equivalent to the vtk\-Glyph3\-D filter, except this filter is specifically for data that has many vertices, making the rendered result faster and less cluttered than the glyph filter. This filter may take a graph or point set as input.

To create an instance of class vtk\-Vertex\-Glyph\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVertexGlyphFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Vertex\-Glyph\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Vertex\-Glyph\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Vertex\-Glyph\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Vertex\-Glyph\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkvoxelcontourstosurfacefilter}{}\section{vtk\-Voxel\-Contours\-To\-Surface\-Filter}\label{vtkgraphics_vtkvoxelcontourstosurfacefilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Voxel\-Contours\-To\-Surface\-Filter is a filter that takes contours and produces surfaces. There are some restrictions for the contours\-:


\begin{DoxyItemize}
\item The contours are input as vtk\-Poly\-Data, with the contours being polys in the vtk\-Poly\-Data.
\item The contours lie on X\-Y planes -\/ each contour has a constant Z
\item The contours are ordered in the polys of the vtk\-Poly\-Data such that all contours on the first (lowest) X\-Y plane are first, then continuing in order of increasing Z value.
\item The X, Y and Z coordinates are all integer values.
\item The desired sampling of the contour data is 1x1x1 -\/ Aspect can be used to control the aspect ratio in the output polygonal dataset.
\end{DoxyItemize}

This filter takes the contours and produces a structured points dataset of signed floating point number indicating distance from a contour. A contouring filter is then applied to generate 3\-D surfaces from a stack of 2\-D contour distance slices. This is done in a streaming fashion so as not to use to much memory.

To create an instance of class vtk\-Voxel\-Contours\-To\-Surface\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVoxelContoursToSurfaceFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Voxel\-Contours\-To\-Surface\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Voxel\-Contours\-To\-Surface\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Voxel\-Contours\-To\-Surface\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Voxel\-Contours\-To\-Surface\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Memory\-Limit\-In\-Bytes (int )} -\/ Set / Get the memory limit in bytes for this filter. This is the limit of the size of the structured points data set that is created for intermediate processing. The data will be streamed through this volume in as many pieces as necessary.  
\item {\ttfamily int = obj.\-Get\-Memory\-Limit\-In\-Bytes ()} -\/ Set / Get the memory limit in bytes for this filter. This is the limit of the size of the structured points data set that is created for intermediate processing. The data will be streamed through this volume in as many pieces as necessary.  
\item {\ttfamily obj.\-Set\-Spacing (double , double , double )}  
\item {\ttfamily obj.\-Set\-Spacing (double a\mbox{[}3\mbox{]})}  
\item {\ttfamily double = obj. Get\-Spacing ()}  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkwarplens}{}\section{vtk\-Warp\-Lens}\label{vtkgraphics_vtkwarplens}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Warp\-Lens is a filter that modifies point coordinates by moving in accord with a lens distortion model.

To create an instance of class vtk\-Warp\-Lens, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkWarpLens
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Warp\-Lens has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Warp\-Lens class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Warp\-Lens = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Warp\-Lens = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Kappa (double kappa)} -\/ Specify second order symmetric radial lens distortion parameter. This is obsoleted by newer instance variables.  
\item {\ttfamily double = obj.\-Get\-Kappa ()} -\/ Specify second order symmetric radial lens distortion parameter. This is obsoleted by newer instance variables.  
\item {\ttfamily obj.\-Set\-Center (double center\-X, double center\-Y)} -\/ Specify the center of radial distortion in pixels. This is obsoleted by newer instance variables.  
\item {\ttfamily double = obj.\-Get\-Center ()} -\/ Specify the center of radial distortion in pixels. This is obsoleted by newer instance variables.  
\item {\ttfamily obj.\-Set\-Principal\-Point (double , double )} -\/ Specify the calibrated principal point of the camera/lens  
\item {\ttfamily obj.\-Set\-Principal\-Point (double a\mbox{[}2\mbox{]})} -\/ Specify the calibrated principal point of the camera/lens  
\item {\ttfamily double = obj. Get\-Principal\-Point ()} -\/ Specify the calibrated principal point of the camera/lens  
\item {\ttfamily obj.\-Set\-K1 (double )} -\/ Specify the symmetric radial distortion parameters for the lens  
\item {\ttfamily double = obj.\-Get\-K1 ()} -\/ Specify the symmetric radial distortion parameters for the lens  
\item {\ttfamily obj.\-Set\-K2 (double )} -\/ Specify the symmetric radial distortion parameters for the lens  
\item {\ttfamily double = obj.\-Get\-K2 ()} -\/ Specify the symmetric radial distortion parameters for the lens  
\item {\ttfamily obj.\-Set\-P1 (double )} -\/ Specify the decentering distortion parameters for the lens  
\item {\ttfamily double = obj.\-Get\-P1 ()} -\/ Specify the decentering distortion parameters for the lens  
\item {\ttfamily obj.\-Set\-P2 (double )} -\/ Specify the decentering distortion parameters for the lens  
\item {\ttfamily double = obj.\-Get\-P2 ()} -\/ Specify the decentering distortion parameters for the lens  
\item {\ttfamily obj.\-Set\-Format\-Width (double )} -\/ Specify the imager format width / height in mm  
\item {\ttfamily double = obj.\-Get\-Format\-Width ()} -\/ Specify the imager format width / height in mm  
\item {\ttfamily obj.\-Set\-Format\-Height (double )} -\/ Specify the imager format width / height in mm  
\item {\ttfamily double = obj.\-Get\-Format\-Height ()} -\/ Specify the imager format width / height in mm  
\item {\ttfamily obj.\-Set\-Image\-Width (int )} -\/ Specify the image width / height in pixels  
\item {\ttfamily int = obj.\-Get\-Image\-Width ()} -\/ Specify the image width / height in pixels  
\item {\ttfamily obj.\-Set\-Image\-Height (int )} -\/ Specify the image width / height in pixels  
\item {\ttfamily int = obj.\-Get\-Image\-Height ()} -\/ Specify the image width / height in pixels  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkwarpscalar}{}\section{vtk\-Warp\-Scalar}\label{vtkgraphics_vtkwarpscalar}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Warp\-Scalar is a filter that modifies point coordinates by moving points along point normals by the scalar amount times the scale factor. Useful for creating carpet or x-\/y-\/z plots.

If normals are not present in data, the Normal instance variable will be used as the direction along which to warp the geometry. If normals are present but you would like to use the Normal instance variable, set the Use\-Normal boolean to true.

If X\-Y\-Plane boolean is set true, then the z-\/value is considered to be a scalar value (still scaled by scale factor), and the displacement is along the z-\/axis. If scalars are also present, these are copied through and can be used to color the surface.

Note that the filter passes both its point data and cell data to its output, except for normals, since these are distorted by the warping.

To create an instance of class vtk\-Warp\-Scalar, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkWarpScalar
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Warp\-Scalar has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Warp\-Scalar class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Warp\-Scalar = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Warp\-Scalar = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Scale\-Factor (double )} -\/ Specify value to scale displacement.  
\item {\ttfamily double = obj.\-Get\-Scale\-Factor ()} -\/ Specify value to scale displacement.  
\item {\ttfamily obj.\-Set\-Use\-Normal (int )} -\/ Turn on/off use of user specified normal. If on, data normals will be ignored and instance variable Normal will be used instead.  
\item {\ttfamily int = obj.\-Get\-Use\-Normal ()} -\/ Turn on/off use of user specified normal. If on, data normals will be ignored and instance variable Normal will be used instead.  
\item {\ttfamily obj.\-Use\-Normal\-On ()} -\/ Turn on/off use of user specified normal. If on, data normals will be ignored and instance variable Normal will be used instead.  
\item {\ttfamily obj.\-Use\-Normal\-Off ()} -\/ Turn on/off use of user specified normal. If on, data normals will be ignored and instance variable Normal will be used instead.  
\item {\ttfamily obj.\-Set\-Normal (double , double , double )} -\/ Normal (i.\-e., direction) along which to warp geometry. Only used if Use\-Normal boolean set to true or no normals available in data.  
\item {\ttfamily obj.\-Set\-Normal (double a\mbox{[}3\mbox{]})} -\/ Normal (i.\-e., direction) along which to warp geometry. Only used if Use\-Normal boolean set to true or no normals available in data.  
\item {\ttfamily double = obj. Get\-Normal ()} -\/ Normal (i.\-e., direction) along which to warp geometry. Only used if Use\-Normal boolean set to true or no normals available in data.  
\item {\ttfamily obj.\-Set\-X\-Y\-Plane (int )} -\/ Turn on/off flag specifying that input data is x-\/y plane. If x-\/y plane, then the z value is used to warp the surface in the z-\/axis direction (times the scale factor) and scalars are used to color the surface.  
\item {\ttfamily int = obj.\-Get\-X\-Y\-Plane ()} -\/ Turn on/off flag specifying that input data is x-\/y plane. If x-\/y plane, then the z value is used to warp the surface in the z-\/axis direction (times the scale factor) and scalars are used to color the surface.  
\item {\ttfamily obj.\-X\-Y\-Plane\-On ()} -\/ Turn on/off flag specifying that input data is x-\/y plane. If x-\/y plane, then the z value is used to warp the surface in the z-\/axis direction (times the scale factor) and scalars are used to color the surface.  
\item {\ttfamily obj.\-X\-Y\-Plane\-Off ()} -\/ Turn on/off flag specifying that input data is x-\/y plane. If x-\/y plane, then the z value is used to warp the surface in the z-\/axis direction (times the scale factor) and scalars are used to color the surface.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkwarpto}{}\section{vtk\-Warp\-To}\label{vtkgraphics_vtkwarpto}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Warp\-To is a filter that modifies point coordinates by moving the points towards a user specified position.

To create an instance of class vtk\-Warp\-To, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkWarpTo
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Warp\-To has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Warp\-To class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Warp\-To = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Warp\-To = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Scale\-Factor (double )} -\/ Set/\-Get the value to scale displacement.  
\item {\ttfamily double = obj.\-Get\-Scale\-Factor ()} -\/ Set/\-Get the value to scale displacement.  
\item {\ttfamily double = obj. Get\-Position ()} -\/ Set/\-Get the position to warp towards.  
\item {\ttfamily obj.\-Set\-Position (double , double , double )} -\/ Set/\-Get the position to warp towards.  
\item {\ttfamily obj.\-Set\-Position (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the position to warp towards.  
\item {\ttfamily obj.\-Set\-Absolute (int )} -\/ Set/\-Get the Absolute ivar. Turning Absolute on causes scale factor of the new position to be one unit away from Position.  
\item {\ttfamily int = obj.\-Get\-Absolute ()} -\/ Set/\-Get the Absolute ivar. Turning Absolute on causes scale factor of the new position to be one unit away from Position.  
\item {\ttfamily obj.\-Absolute\-On ()} -\/ Set/\-Get the Absolute ivar. Turning Absolute on causes scale factor of the new position to be one unit away from Position.  
\item {\ttfamily obj.\-Absolute\-Off ()} -\/ Set/\-Get the Absolute ivar. Turning Absolute on causes scale factor of the new position to be one unit away from Position.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkwarpvector}{}\section{vtk\-Warp\-Vector}\label{vtkgraphics_vtkwarpvector}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Warp\-Vector is a filter that modifies point coordinates by moving points along vector times the scale factor. Useful for showing flow profiles or mechanical deformation.

The filter passes both its point data and cell data to its output.

To create an instance of class vtk\-Warp\-Vector, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkWarpVector
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Warp\-Vector has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Warp\-Vector class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Warp\-Vector = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Warp\-Vector = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Scale\-Factor (double )} -\/ Specify value to scale displacement.  
\item {\ttfamily double = obj.\-Get\-Scale\-Factor ()} -\/ Specify value to scale displacement.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkwindowedsincpolydatafilter}{}\section{vtk\-Windowed\-Sinc\-Poly\-Data\-Filter}\label{vtkgraphics_vtkwindowedsincpolydatafilter}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Windowed\-Sinc\-Poly\-Data\-Filer adjust point coordinate using a windowed sinc function interpolation kernel. The effect is to \char`\"{}relax\char`\"{} the mesh, making the cells better shaped and the vertices more evenly distributed. Note that this filter operates the lines, polygons, and triangle strips composing an instance of vtk\-Poly\-Data. Vertex or poly-\/vertex cells are never modified.

The algorithm proceeds as follows. For each vertex v, a topological and geometric analysis is performed to determine which vertices are connected to v, and which cells are connected to v. Then, a connectivity array is constructed for each vertex. (The connectivity array is a list of lists of vertices that directly attach to each vertex.) Next, an iteration phase begins over all vertices. For each vertex v, the coordinates of v are modified using a windowed sinc function interpolation kernel. Taubin describes this methodology is the I\-B\-M tech report R\-C-\/20404 (\#90237, dated 3/12/96) \char`\"{}\-Optimal Surface Smoothing as Filter Design\char`\"{} G. Taubin, T. Zhang and G. Golub. (Zhang and Golub are at Stanford University).

This report discusses using standard signal processing low-\/pass filters (in particular windowed sinc functions) to smooth polyhedra. The transfer functions of the low-\/pass filters are approximated by Chebyshev polynomials. This facilitates applying the filters in an iterative diffusion process (as opposed to a kernel convolution). The more smoothing iterations applied, the higher the degree of polynomial approximating the low-\/pass filter transfer function. Each smoothing iteration, therefore, applies the next higher term of the Chebyshev filter approximation to the polyhedron. This decoupling of the filter into an iteratively applied polynomial is possible since the Chebyshev polynomials are orthogonal, i.\-e. increasing the order of the approximation to the filter transfer function does not alter the previously calculated coefficients for the low order terms.

Note\-: Care must be taken to avoid smoothing with too few iterations. A Chebyshev approximation with too few terms is an poor approximation. The first few smoothing iterations represent a severe scaling and translation of the data. Subsequent iterations cause the smoothed polyhedron to converge to the true location and scale of the object. We have attempted to protect against this by automatically adjusting the filter, effectively widening the pass band. This adjustment is only possible if the number of iterations is greater than 1. Note that this sacrifices some degree of smoothing for model integrity. For those interested, the filter is adjusted by searching for a value sigma such that the actual pass band is k\-\_\-pb + sigma and such that the filter transfer function evaluates to unity at k\-\_\-pb, i.\-e. f(k\-\_\-pb) = 1

To improve the numerical stability of the solution and minimize the scaling the translation effects, the algorithm can translate and scale the position coordinates to within the unit cube \mbox{[}-\/1, 1\mbox{]}, perform the smoothing, and translate and scale the position coordinates back to the original coordinate frame. This mode is controlled with the Normalize\-Coordinates\-On() / Normalize\-Coordinates\-Off() methods. For legacy reasons, the default is Normalize\-Coordinates\-Off.

This implementation is currently limited to using an interpolation kernel based on Hamming windows. Other windows (such as Hann, Blackman, Kaiser, Lanczos, Gaussian, and exponential windows) could be used instead.

There are some special instance variables used to control the execution of this filter. (These ivars basically control what vertices can be smoothed, and the creation of the connectivity array.) The Boundary\-Smoothing ivar enables/disables the smoothing operation on vertices that are on the \char`\"{}boundary\char`\"{} of the mesh. A boundary vertex is one that is surrounded by a semi-\/cycle of polygons (or used by a single line).

Another important ivar is Feature\-Edge\-Smoothing. If this ivar is enabled, then interior vertices are classified as either \char`\"{}simple\char`\"{}, \char`\"{}interior edge\char`\"{}, or \char`\"{}fixed\char`\"{}, and smoothed differently. (Interior vertices are manifold vertices surrounded by a cycle of polygons; or used by two line cells.) The classification is based on the number of feature edges attached to v. A feature edge occurs when the angle between the two surface normals of a polygon sharing an edge is greater than the Feature\-Angle ivar. Then, vertices used by no feature edges are classified \char`\"{}simple\char`\"{}, vertices used by exactly two feature edges are classified \char`\"{}interior edge\char`\"{}, and all others are \char`\"{}fixed\char`\"{} vertices.

Once the classification is known, the vertices are smoothed differently. Corner (i.\-e., fixed) vertices are not smoothed at all. Simple vertices are smoothed as before . Interior edge vertices are smoothed only along their two connected edges, and only if the angle between the edges is less than the Edge\-Angle ivar.

The total smoothing can be controlled by using two ivars. The Number\-Of\-Iterations determines the maximum number of smoothing passes. The Number\-Of\-Iterations corresponds to the degree of the polynomial that is used to approximate the windowed sinc function. Ten or twenty iterations is all the is usually necessary. Contrast this with vtk\-Smooth\-Poly\-Data\-Filter which usually requires 100 to 200 smoothing iterations. vtk\-Smooth\-Poly\-Data\-Filter is also not an approximation to an ideal low-\/pass filter, which can cause the geometry to shrink as the amount of smoothing increases.

The second ivar is the specification of the Pass\-Band for the windowed sinc filter. By design, the Pass\-Band is specified as a doubleing point number between 0 and 2. Lower Pass\-Band values produce more smoothing. A good default value for the Pass\-Band is 0.\-1 (for those interested, the Pass\-Band (and frequencies) for Poly\-Data are based on the valence of the vertices, this limits all the frequency modes in a polyhedral mesh to between 0 and 2.)

There are two instance variables that control the generation of error data. If the ivar Generate\-Error\-Scalars is on, then a scalar value indicating the distance of each vertex from its original position is computed. If the ivar Generate\-Error\-Vectors is on, then a vector representing change in position is computed.

To create an instance of class vtk\-Windowed\-Sinc\-Poly\-Data\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkWindowedSincPolyDataFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Windowed\-Sinc\-Poly\-Data\-Filter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Windowed\-Sinc\-Poly\-Data\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Windowed\-Sinc\-Poly\-Data\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Windowed\-Sinc\-Poly\-Data\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Number\-Of\-Iterations (int )} -\/ Specify the number of iterations (or degree of the polynomial approximating the windowed sinc function).  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Iterations\-Min\-Value ()} -\/ Specify the number of iterations (or degree of the polynomial approximating the windowed sinc function).  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Iterations\-Max\-Value ()} -\/ Specify the number of iterations (or degree of the polynomial approximating the windowed sinc function).  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Iterations ()} -\/ Specify the number of iterations (or degree of the polynomial approximating the windowed sinc function).  
\item {\ttfamily obj.\-Set\-Pass\-Band (double )} -\/ Set the passband value for the windowed sinc filter  
\item {\ttfamily double = obj.\-Get\-Pass\-Band\-Min\-Value ()} -\/ Set the passband value for the windowed sinc filter  
\item {\ttfamily double = obj.\-Get\-Pass\-Band\-Max\-Value ()} -\/ Set the passband value for the windowed sinc filter  
\item {\ttfamily double = obj.\-Get\-Pass\-Band ()} -\/ Set the passband value for the windowed sinc filter  
\item {\ttfamily obj.\-Set\-Normalize\-Coordinates (int )} -\/ Turn on/off coordinate normalization. The positions can be translated and scaled such that they fit within a \mbox{[}-\/1, 1\mbox{]} prior to the smoothing computation. The default is off. The numerical stability of the solution can be improved by turning normalization on. If normalization is on, the coordinates will be rescaled to the original coordinate system after smoothing has completed.  
\item {\ttfamily int = obj.\-Get\-Normalize\-Coordinates ()} -\/ Turn on/off coordinate normalization. The positions can be translated and scaled such that they fit within a \mbox{[}-\/1, 1\mbox{]} prior to the smoothing computation. The default is off. The numerical stability of the solution can be improved by turning normalization on. If normalization is on, the coordinates will be rescaled to the original coordinate system after smoothing has completed.  
\item {\ttfamily obj.\-Normalize\-Coordinates\-On ()} -\/ Turn on/off coordinate normalization. The positions can be translated and scaled such that they fit within a \mbox{[}-\/1, 1\mbox{]} prior to the smoothing computation. The default is off. The numerical stability of the solution can be improved by turning normalization on. If normalization is on, the coordinates will be rescaled to the original coordinate system after smoothing has completed.  
\item {\ttfamily obj.\-Normalize\-Coordinates\-Off ()} -\/ Turn on/off coordinate normalization. The positions can be translated and scaled such that they fit within a \mbox{[}-\/1, 1\mbox{]} prior to the smoothing computation. The default is off. The numerical stability of the solution can be improved by turning normalization on. If normalization is on, the coordinates will be rescaled to the original coordinate system after smoothing has completed.  
\item {\ttfamily obj.\-Set\-Feature\-Edge\-Smoothing (int )} -\/ Turn on/off smoothing along sharp interior edges.  
\item {\ttfamily int = obj.\-Get\-Feature\-Edge\-Smoothing ()} -\/ Turn on/off smoothing along sharp interior edges.  
\item {\ttfamily obj.\-Feature\-Edge\-Smoothing\-On ()} -\/ Turn on/off smoothing along sharp interior edges.  
\item {\ttfamily obj.\-Feature\-Edge\-Smoothing\-Off ()} -\/ Turn on/off smoothing along sharp interior edges.  
\item {\ttfamily obj.\-Set\-Feature\-Angle (double )} -\/ Specify the feature angle for sharp edge identification.  
\item {\ttfamily double = obj.\-Get\-Feature\-Angle\-Min\-Value ()} -\/ Specify the feature angle for sharp edge identification.  
\item {\ttfamily double = obj.\-Get\-Feature\-Angle\-Max\-Value ()} -\/ Specify the feature angle for sharp edge identification.  
\item {\ttfamily double = obj.\-Get\-Feature\-Angle ()} -\/ Specify the feature angle for sharp edge identification.  
\item {\ttfamily obj.\-Set\-Edge\-Angle (double )} -\/ Specify the edge angle to control smoothing along edges (either interior or boundary).  
\item {\ttfamily double = obj.\-Get\-Edge\-Angle\-Min\-Value ()} -\/ Specify the edge angle to control smoothing along edges (either interior or boundary).  
\item {\ttfamily double = obj.\-Get\-Edge\-Angle\-Max\-Value ()} -\/ Specify the edge angle to control smoothing along edges (either interior or boundary).  
\item {\ttfamily double = obj.\-Get\-Edge\-Angle ()} -\/ Specify the edge angle to control smoothing along edges (either interior or boundary).  
\item {\ttfamily obj.\-Set\-Boundary\-Smoothing (int )} -\/ Turn on/off the smoothing of vertices on the boundary of the mesh.  
\item {\ttfamily int = obj.\-Get\-Boundary\-Smoothing ()} -\/ Turn on/off the smoothing of vertices on the boundary of the mesh.  
\item {\ttfamily obj.\-Boundary\-Smoothing\-On ()} -\/ Turn on/off the smoothing of vertices on the boundary of the mesh.  
\item {\ttfamily obj.\-Boundary\-Smoothing\-Off ()} -\/ Turn on/off the smoothing of vertices on the boundary of the mesh.  
\item {\ttfamily obj.\-Set\-Non\-Manifold\-Smoothing (int )} -\/ Smooth non-\/manifold vertices.  
\item {\ttfamily int = obj.\-Get\-Non\-Manifold\-Smoothing ()} -\/ Smooth non-\/manifold vertices.  
\item {\ttfamily obj.\-Non\-Manifold\-Smoothing\-On ()} -\/ Smooth non-\/manifold vertices.  
\item {\ttfamily obj.\-Non\-Manifold\-Smoothing\-Off ()} -\/ Smooth non-\/manifold vertices.  
\item {\ttfamily obj.\-Set\-Generate\-Error\-Scalars (int )} -\/ Turn on/off the generation of scalar distance values.  
\item {\ttfamily int = obj.\-Get\-Generate\-Error\-Scalars ()} -\/ Turn on/off the generation of scalar distance values.  
\item {\ttfamily obj.\-Generate\-Error\-Scalars\-On ()} -\/ Turn on/off the generation of scalar distance values.  
\item {\ttfamily obj.\-Generate\-Error\-Scalars\-Off ()} -\/ Turn on/off the generation of scalar distance values.  
\item {\ttfamily obj.\-Set\-Generate\-Error\-Vectors (int )} -\/ Turn on/off the generation of error vectors.  
\item {\ttfamily int = obj.\-Get\-Generate\-Error\-Vectors ()} -\/ Turn on/off the generation of error vectors.  
\item {\ttfamily obj.\-Generate\-Error\-Vectors\-On ()} -\/ Turn on/off the generation of error vectors.  
\item {\ttfamily obj.\-Generate\-Error\-Vectors\-Off ()} -\/ Turn on/off the generation of error vectors.  
\end{DoxyItemize}\hypertarget{vtkgraphics_vtkyoungsmaterialinterface}{}\section{vtk\-Youngs\-Material\-Interface}\label{vtkgraphics_vtkyoungsmaterialinterface}
Section\-: \hyperlink{sec_vtkgraphics}{Visualization Toolkit Graphics Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Reconstructs material interfaces from a mesh containing mixed cells (where several materials are mixed) this implementation is based on the youngs algorithm, generalized to arbitrary cell types and works on both 2\-D and 3\-D meshes. the main advantage of the youngs algorithm is it guarantees the material volume correctness. for 2\-D meshes, the Axis\-Symetric flag allows to switch between a pure 2\-D (plannar) algorithm and an axis symetric 2\-D algorithm handling volumes of revolution.

.S\-E\-C\-T\-I\-O\-N Thanks This file is part of the generalized Youngs material interface reconstruction algorithm contributed by \par
 C\-E\-A/\-D\-I\-F -\/ Commissariat a l'Energie Atomique, Centre D\-A\-M Ile-\/\-De-\/\-France \par
 B\-P12, F-\/91297 Arpajon, France. \par
 Implementation by Thierry Carrard (\href{mailto:thierry.carrard@cea.fr}{\tt thierry.\-carrard@cea.\-fr})

To create an instance of class vtk\-Youngs\-Material\-Interface, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkYoungsMaterialInterface
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Youngs\-Material\-Interface has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Youngs\-Material\-Interface class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Youngs\-Material\-Interface = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Youngs\-Material\-Interface = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Inverse\-Normal (int )} -\/ Set/\-Get wether the normal vector has to be flipped.  
\item {\ttfamily int = obj.\-Get\-Inverse\-Normal ()} -\/ Set/\-Get wether the normal vector has to be flipped.  
\item {\ttfamily obj.\-Inverse\-Normal\-On ()} -\/ Set/\-Get wether the normal vector has to be flipped.  
\item {\ttfamily obj.\-Inverse\-Normal\-Off ()} -\/ Set/\-Get wether the normal vector has to be flipped.  
\item {\ttfamily obj.\-Set\-Reverse\-Material\-Order (int )} -\/ If this flag is on, material order in reversed. Otherwise, materials are sorted in ascending order depending on the given ordering array.  
\item {\ttfamily int = obj.\-Get\-Reverse\-Material\-Order ()} -\/ If this flag is on, material order in reversed. Otherwise, materials are sorted in ascending order depending on the given ordering array.  
\item {\ttfamily obj.\-Reverse\-Material\-Order\-On ()} -\/ If this flag is on, material order in reversed. Otherwise, materials are sorted in ascending order depending on the given ordering array.  
\item {\ttfamily obj.\-Reverse\-Material\-Order\-Off ()} -\/ If this flag is on, material order in reversed. Otherwise, materials are sorted in ascending order depending on the given ordering array.  
\item {\ttfamily obj.\-Set\-Onion\-Peel (int )} -\/ Set/\-Get Onion\-Peel flag. if this flag is on, the normal vector of the first material (which depends on material ordering) is used for all materials.  
\item {\ttfamily int = obj.\-Get\-Onion\-Peel ()} -\/ Set/\-Get Onion\-Peel flag. if this flag is on, the normal vector of the first material (which depends on material ordering) is used for all materials.  
\item {\ttfamily obj.\-Onion\-Peel\-On ()} -\/ Set/\-Get Onion\-Peel flag. if this flag is on, the normal vector of the first material (which depends on material ordering) is used for all materials.  
\item {\ttfamily obj.\-Onion\-Peel\-Off ()} -\/ Set/\-Get Onion\-Peel flag. if this flag is on, the normal vector of the first material (which depends on material ordering) is used for all materials.  
\item {\ttfamily obj.\-Set\-Axis\-Symetric (int )} -\/ Turns on/off Axis\-Symetric computation of 2\-D interfaces. in axis symetric mode, 2\-D meshes are understood as volumes of revolution.  
\item {\ttfamily int = obj.\-Get\-Axis\-Symetric ()} -\/ Turns on/off Axis\-Symetric computation of 2\-D interfaces. in axis symetric mode, 2\-D meshes are understood as volumes of revolution.  
\item {\ttfamily obj.\-Axis\-Symetric\-On ()} -\/ Turns on/off Axis\-Symetric computation of 2\-D interfaces. in axis symetric mode, 2\-D meshes are understood as volumes of revolution.  
\item {\ttfamily obj.\-Axis\-Symetric\-Off ()} -\/ Turns on/off Axis\-Symetric computation of 2\-D interfaces. in axis symetric mode, 2\-D meshes are understood as volumes of revolution.  
\item {\ttfamily obj.\-Set\-Use\-Fraction\-As\-Distance (int )} -\/ when Use\-Fraction\-As\-Distance is true, the volume fraction is interpreted as the distance of the cutting plane from the origin. in axis symetric mode, 2\-D meshes are understood as volumes of revolution.  
\item {\ttfamily int = obj.\-Get\-Use\-Fraction\-As\-Distance ()} -\/ when Use\-Fraction\-As\-Distance is true, the volume fraction is interpreted as the distance of the cutting plane from the origin. in axis symetric mode, 2\-D meshes are understood as volumes of revolution.  
\item {\ttfamily obj.\-Use\-Fraction\-As\-Distance\-On ()} -\/ when Use\-Fraction\-As\-Distance is true, the volume fraction is interpreted as the distance of the cutting plane from the origin. in axis symetric mode, 2\-D meshes are understood as volumes of revolution.  
\item {\ttfamily obj.\-Use\-Fraction\-As\-Distance\-Off ()} -\/ when Use\-Fraction\-As\-Distance is true, the volume fraction is interpreted as the distance of the cutting plane from the origin. in axis symetric mode, 2\-D meshes are understood as volumes of revolution.  
\item {\ttfamily obj.\-Set\-Fill\-Material (int )} -\/ When Fill\-Material is set to 1, the volume containing material is output and not only the interface surface.  
\item {\ttfamily int = obj.\-Get\-Fill\-Material ()} -\/ When Fill\-Material is set to 1, the volume containing material is output and not only the interface surface.  
\item {\ttfamily obj.\-Fill\-Material\-On ()} -\/ When Fill\-Material is set to 1, the volume containing material is output and not only the interface surface.  
\item {\ttfamily obj.\-Fill\-Material\-Off ()} -\/ When Fill\-Material is set to 1, the volume containing material is output and not only the interface surface.  
\item {\ttfamily obj.\-Set\-Two\-Materials\-Optimization (int )} -\/ Triggers some additional optimizations for cells containing only two materials. This option might produce different result than expected if the sum of volume fractions is not 1.  
\item {\ttfamily int = obj.\-Get\-Two\-Materials\-Optimization ()} -\/ Triggers some additional optimizations for cells containing only two materials. This option might produce different result than expected if the sum of volume fractions is not 1.  
\item {\ttfamily obj.\-Two\-Materials\-Optimization\-On ()} -\/ Triggers some additional optimizations for cells containing only two materials. This option might produce different result than expected if the sum of volume fractions is not 1.  
\item {\ttfamily obj.\-Two\-Materials\-Optimization\-Off ()} -\/ Triggers some additional optimizations for cells containing only two materials. This option might produce different result than expected if the sum of volume fractions is not 1.  
\item {\ttfamily obj.\-Set\-Volume\-Fraction\-Range (double , double )} -\/ Set/\-Get minimum and maximum volume fraction value. if a material fills a volume above the minimum value, the material is considered to be void. if a material fills a volume fraction beyond the maximum value it is considered as filling the whole volume.  
\item {\ttfamily obj.\-Set\-Volume\-Fraction\-Range (double a\mbox{[}2\mbox{]})} -\/ Set/\-Get minimum and maximum volume fraction value. if a material fills a volume above the minimum value, the material is considered to be void. if a material fills a volume fraction beyond the maximum value it is considered as filling the whole volume.  
\item {\ttfamily double = obj. Get\-Volume\-Fraction\-Range ()} -\/ Set/\-Get minimum and maximum volume fraction value. if a material fills a volume above the minimum value, the material is considered to be void. if a material fills a volume fraction beyond the maximum value it is considered as filling the whole volume.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Materials (int n)} -\/ Sets/\-Gets the number of materials.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Materials ()} -\/ Sets/\-Gets the number of materials.  
\item {\ttfamily obj.\-Set\-Material\-Arrays (int i, string volume\-Fraction, string interface\-Normal, string material\-Ordering)} -\/ Set ith Material arrays to be used as volume fraction, interface normal and material ordering. Each parameter name a cell array.  
\item {\ttfamily obj.\-Set\-Material\-Volume\-Fraction\-Array (int i, string volume)} -\/ Set ith Material arrays to be used as volume fraction, interface normal and material ordering. Each parameter name a cell array.  
\item {\ttfamily obj.\-Set\-Material\-Normal\-Array (int i, string normal)} -\/ Set ith Material arrays to be used as volume fraction, interface normal and material ordering. Each parameter name a cell array.  
\item {\ttfamily obj.\-Set\-Material\-Ordering\-Array (int i, string ordering)} -\/ Set ith Material arrays to be used as volume fraction, interface normal and material ordering. Each parameter name a cell array.  
\item {\ttfamily obj.\-Remove\-All\-Materials ()} -\/ Removes all meterials previously added.  
\end{DoxyItemize}