
\begin{DoxyItemize}
\item \hyperlink{vtkimaging_vtkbooleantexture}{vtk\-Boolean\-Texture}  
\item \hyperlink{vtkimaging_vtkextractvoi}{vtk\-Extract\-V\-O\-I}  
\item \hyperlink{vtkimaging_vtkfastsplatter}{vtk\-Fast\-Splatter}  
\item \hyperlink{vtkimaging_vtkgaussiansplatter}{vtk\-Gaussian\-Splatter}  
\item \hyperlink{vtkimaging_vtkimageaccumulate}{vtk\-Image\-Accumulate}  
\item \hyperlink{vtkimaging_vtkimageanisotropicdiffusion2d}{vtk\-Image\-Anisotropic\-Diffusion2\-D}  
\item \hyperlink{vtkimaging_vtkimageanisotropicdiffusion3d}{vtk\-Image\-Anisotropic\-Diffusion3\-D}  
\item \hyperlink{vtkimaging_vtkimageappend}{vtk\-Image\-Append}  
\item \hyperlink{vtkimaging_vtkimageappendcomponents}{vtk\-Image\-Append\-Components}  
\item \hyperlink{vtkimaging_vtkimageblend}{vtk\-Image\-Blend}  
\item \hyperlink{vtkimaging_vtkimagebutterworthhighpass}{vtk\-Image\-Butterworth\-High\-Pass}  
\item \hyperlink{vtkimaging_vtkimagebutterworthlowpass}{vtk\-Image\-Butterworth\-Low\-Pass}  
\item \hyperlink{vtkimaging_vtkimagecachefilter}{vtk\-Image\-Cache\-Filter}  
\item \hyperlink{vtkimaging_vtkimagecanvassource2d}{vtk\-Image\-Canvas\-Source2\-D}  
\item \hyperlink{vtkimaging_vtkimagecast}{vtk\-Image\-Cast}  
\item \hyperlink{vtkimaging_vtkimagechangeinformation}{vtk\-Image\-Change\-Information}  
\item \hyperlink{vtkimaging_vtkimagecheckerboard}{vtk\-Image\-Checkerboard}  
\item \hyperlink{vtkimaging_vtkimagecityblockdistance}{vtk\-Image\-City\-Block\-Distance}  
\item \hyperlink{vtkimaging_vtkimageclip}{vtk\-Image\-Clip}  
\item \hyperlink{vtkimaging_vtkimageconnector}{vtk\-Image\-Connector}  
\item \hyperlink{vtkimaging_vtkimageconstantpad}{vtk\-Image\-Constant\-Pad}  
\item \hyperlink{vtkimaging_vtkimagecontinuousdilate3d}{vtk\-Image\-Continuous\-Dilate3\-D}  
\item \hyperlink{vtkimaging_vtkimagecontinuouserode3d}{vtk\-Image\-Continuous\-Erode3\-D}  
\item \hyperlink{vtkimaging_vtkimageconvolve}{vtk\-Image\-Convolve}  
\item \hyperlink{vtkimaging_vtkimagecorrelation}{vtk\-Image\-Correlation}  
\item \hyperlink{vtkimaging_vtkimagecursor3d}{vtk\-Image\-Cursor3\-D}  
\item \hyperlink{vtkimaging_vtkimagedatastreamer}{vtk\-Image\-Data\-Streamer}  
\item \hyperlink{vtkimaging_vtkimagedecomposefilter}{vtk\-Image\-Decompose\-Filter}  
\item \hyperlink{vtkimaging_vtkimagedifference}{vtk\-Image\-Difference}  
\item \hyperlink{vtkimaging_vtkimagedilateerode3d}{vtk\-Image\-Dilate\-Erode3\-D}  
\item \hyperlink{vtkimaging_vtkimagedivergence}{vtk\-Image\-Divergence}  
\item \hyperlink{vtkimaging_vtkimagedotproduct}{vtk\-Image\-Dot\-Product}  
\item \hyperlink{vtkimaging_vtkimageellipsoidsource}{vtk\-Image\-Ellipsoid\-Source}  
\item \hyperlink{vtkimaging_vtkimageeuclideandistance}{vtk\-Image\-Euclidean\-Distance}  
\item \hyperlink{vtkimaging_vtkimageeuclideantopolar}{vtk\-Image\-Euclidean\-To\-Polar}  
\item \hyperlink{vtkimaging_vtkimageexport}{vtk\-Image\-Export}  
\item \hyperlink{vtkimaging_vtkimageextractcomponents}{vtk\-Image\-Extract\-Components}  
\item \hyperlink{vtkimaging_vtkimagefft}{vtk\-Image\-F\-F\-T}  
\item \hyperlink{vtkimaging_vtkimageflip}{vtk\-Image\-Flip}  
\item \hyperlink{vtkimaging_vtkimagefouriercenter}{vtk\-Image\-Fourier\-Center}  
\item \hyperlink{vtkimaging_vtkimagefourierfilter}{vtk\-Image\-Fourier\-Filter}  
\item \hyperlink{vtkimaging_vtkimagegaussiansmooth}{vtk\-Image\-Gaussian\-Smooth}  
\item \hyperlink{vtkimaging_vtkimagegaussiansource}{vtk\-Image\-Gaussian\-Source}  
\item \hyperlink{vtkimaging_vtkimagegradient}{vtk\-Image\-Gradient}  
\item \hyperlink{vtkimaging_vtkimagegradientmagnitude}{vtk\-Image\-Gradient\-Magnitude}  
\item \hyperlink{vtkimaging_vtkimagegridsource}{vtk\-Image\-Grid\-Source}  
\item \hyperlink{vtkimaging_vtkimagehsitorgb}{vtk\-Image\-H\-S\-I\-To\-R\-G\-B}  
\item \hyperlink{vtkimaging_vtkimagehsvtorgb}{vtk\-Image\-H\-S\-V\-To\-R\-G\-B}  
\item \hyperlink{vtkimaging_vtkimagehybridmedian2d}{vtk\-Image\-Hybrid\-Median2\-D}  
\item \hyperlink{vtkimaging_vtkimageidealhighpass}{vtk\-Image\-Ideal\-High\-Pass}  
\item \hyperlink{vtkimaging_vtkimageideallowpass}{vtk\-Image\-Ideal\-Low\-Pass}  
\item \hyperlink{vtkimaging_vtkimageimport}{vtk\-Image\-Import}  
\item \hyperlink{vtkimaging_vtkimageimportexecutive}{vtk\-Image\-Import\-Executive}  
\item \hyperlink{vtkimaging_vtkimageislandremoval2d}{vtk\-Image\-Island\-Removal2\-D}  
\item \hyperlink{vtkimaging_vtkimageiteratefilter}{vtk\-Image\-Iterate\-Filter}  
\item \hyperlink{vtkimaging_vtkimagelaplacian}{vtk\-Image\-Laplacian}  
\item \hyperlink{vtkimaging_vtkimagelogarithmicscale}{vtk\-Image\-Logarithmic\-Scale}  
\item \hyperlink{vtkimaging_vtkimagelogic}{vtk\-Image\-Logic}  
\item \hyperlink{vtkimaging_vtkimageluminance}{vtk\-Image\-Luminance}  
\item \hyperlink{vtkimaging_vtkimagemagnify}{vtk\-Image\-Magnify}  
\item \hyperlink{vtkimaging_vtkimagemagnitude}{vtk\-Image\-Magnitude}  
\item \hyperlink{vtkimaging_vtkimagemandelbrotsource}{vtk\-Image\-Mandelbrot\-Source}  
\item \hyperlink{vtkimaging_vtkimagemaptocolors}{vtk\-Image\-Map\-To\-Colors}  
\item \hyperlink{vtkimaging_vtkimagemaptorgba}{vtk\-Image\-Map\-To\-R\-G\-B\-A}  
\item \hyperlink{vtkimaging_vtkimagemaptowindowlevelcolors}{vtk\-Image\-Map\-To\-Window\-Level\-Colors}  
\item \hyperlink{vtkimaging_vtkimagemask}{vtk\-Image\-Mask}  
\item \hyperlink{vtkimaging_vtkimagemaskbits}{vtk\-Image\-Mask\-Bits}  
\item \hyperlink{vtkimaging_vtkimagemathematics}{vtk\-Image\-Mathematics}  
\item \hyperlink{vtkimaging_vtkimagemedian3d}{vtk\-Image\-Median3\-D}  
\item \hyperlink{vtkimaging_vtkimagemirrorpad}{vtk\-Image\-Mirror\-Pad}  
\item \hyperlink{vtkimaging_vtkimagenoisesource}{vtk\-Image\-Noise\-Source}  
\item \hyperlink{vtkimaging_vtkimagenonmaximumsuppression}{vtk\-Image\-Non\-Maximum\-Suppression}  
\item \hyperlink{vtkimaging_vtkimagenormalize}{vtk\-Image\-Normalize}  
\item \hyperlink{vtkimaging_vtkimageopenclose3d}{vtk\-Image\-Open\-Close3\-D}  
\item \hyperlink{vtkimaging_vtkimagepadfilter}{vtk\-Image\-Pad\-Filter}  
\item \hyperlink{vtkimaging_vtkimagepermute}{vtk\-Image\-Permute}  
\item \hyperlink{vtkimaging_vtkimagequantizergbtoindex}{vtk\-Image\-Quantize\-R\-G\-B\-To\-Index}  
\item \hyperlink{vtkimaging_vtkimagerange3d}{vtk\-Image\-Range3\-D}  
\item \hyperlink{vtkimaging_vtkimagerectilinearwipe}{vtk\-Image\-Rectilinear\-Wipe}  
\item \hyperlink{vtkimaging_vtkimageresample}{vtk\-Image\-Resample}  
\item \hyperlink{vtkimaging_vtkimagereslice}{vtk\-Image\-Reslice}  
\item \hyperlink{vtkimaging_vtkimagerfft}{vtk\-Image\-R\-F\-F\-T}  
\item \hyperlink{vtkimaging_vtkimagergbtohsi}{vtk\-Image\-R\-G\-B\-To\-H\-S\-I}  
\item \hyperlink{vtkimaging_vtkimagergbtohsv}{vtk\-Image\-R\-G\-B\-To\-H\-S\-V}  
\item \hyperlink{vtkimaging_vtkimageseedconnectivity}{vtk\-Image\-Seed\-Connectivity}  
\item \hyperlink{vtkimaging_vtkimageseparableconvolution}{vtk\-Image\-Separable\-Convolution}  
\item \hyperlink{vtkimaging_vtkimageshiftscale}{vtk\-Image\-Shift\-Scale}  
\item \hyperlink{vtkimaging_vtkimageshrink3d}{vtk\-Image\-Shrink3\-D}  
\item \hyperlink{vtkimaging_vtkimagesinusoidsource}{vtk\-Image\-Sinusoid\-Source}  
\item \hyperlink{vtkimaging_vtkimageskeleton2d}{vtk\-Image\-Skeleton2\-D}  
\item \hyperlink{vtkimaging_vtkimagesobel2d}{vtk\-Image\-Sobel2\-D}  
\item \hyperlink{vtkimaging_vtkimagesobel3d}{vtk\-Image\-Sobel3\-D}  
\item \hyperlink{vtkimaging_vtkimagespatialalgorithm}{vtk\-Image\-Spatial\-Algorithm}  
\item \hyperlink{vtkimaging_vtkimagespatialfilter}{vtk\-Image\-Spatial\-Filter}  
\item \hyperlink{vtkimaging_vtkimagestencil}{vtk\-Image\-Stencil}  
\item \hyperlink{vtkimaging_vtkimagestencildata}{vtk\-Image\-Stencil\-Data}  
\item \hyperlink{vtkimaging_vtkimagestencilsource}{vtk\-Image\-Stencil\-Source}  
\item \hyperlink{vtkimaging_vtkimagethreshold}{vtk\-Image\-Threshold}  
\item \hyperlink{vtkimaging_vtkimagetoimagestencil}{vtk\-Image\-To\-Image\-Stencil}  
\item \hyperlink{vtkimaging_vtkimagetranslateextent}{vtk\-Image\-Translate\-Extent}  
\item \hyperlink{vtkimaging_vtkimagevariance3d}{vtk\-Image\-Variance3\-D}  
\item \hyperlink{vtkimaging_vtkimageweightedsum}{vtk\-Image\-Weighted\-Sum}  
\item \hyperlink{vtkimaging_vtkimagewrappad}{vtk\-Image\-Wrap\-Pad}  
\item \hyperlink{vtkimaging_vtkimplicitfunctiontoimagestencil}{vtk\-Implicit\-Function\-To\-Image\-Stencil}  
\item \hyperlink{vtkimaging_vtkpointload}{vtk\-Point\-Load}  
\item \hyperlink{vtkimaging_vtkrtanalyticsource}{vtk\-R\-T\-Analytic\-Source}  
\item \hyperlink{vtkimaging_vtksamplefunction}{vtk\-Sample\-Function}  
\item \hyperlink{vtkimaging_vtkshepardmethod}{vtk\-Shepard\-Method}  
\item \hyperlink{vtkimaging_vtksimpleimagefilterexample}{vtk\-Simple\-Image\-Filter\-Example}  
\item \hyperlink{vtkimaging_vtksurfacereconstructionfilter}{vtk\-Surface\-Reconstruction\-Filter}  
\item \hyperlink{vtkimaging_vtktriangulartexture}{vtk\-Triangular\-Texture}  
\item \hyperlink{vtkimaging_vtkvoxelmodeller}{vtk\-Voxel\-Modeller}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkbooleantexture}{}\section{vtk\-Boolean\-Texture}\label{vtkimaging_vtkbooleantexture}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Boolean\-Texture is a filter to generate a 2\-D texture map based on combinations of inside, outside, and on region boundary. The \char`\"{}region\char`\"{} is implicitly represented via 2\-D texture coordinates. These texture coordinates are normally generated using a filter like vtk\-Implicit\-Texture\-Coords, which generates the texture coordinates for any implicit function.

vtk\-Boolean\-Texture generates the map according to the s-\/t texture coordinates plus the notion of being in, on, or outside of a region. An in region is when the texture coordinate is between (0,0.\-5-\/thickness/2). An out region is where the texture coordinate is (0.\-5+thickness/2). An on region is between (0.\-5-\/thickness/2,0.\-5+thickness/2). The combination in, on, and out for each of the s-\/t texture coordinates results in 16 possible combinations (see text). For each combination, a different value of intensity and transparency can be assigned. To assign maximum intensity and/or opacity use the value 255. A minimum value of 0 results in a black region (for intensity) and a fully transparent region (for transparency).

To create an instance of class vtk\-Boolean\-Texture, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBooleanTexture
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Boolean\-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\-Boolean\-Texture class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Boolean\-Texture = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Boolean\-Texture = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-X\-Size (int )} -\/ Set the X texture map dimension.  
\item {\ttfamily int = obj.\-Get\-X\-Size ()} -\/ Set the X texture map dimension.  
\item {\ttfamily obj.\-Set\-Y\-Size (int )} -\/ Set the Y texture map dimension.  
\item {\ttfamily int = obj.\-Get\-Y\-Size ()} -\/ Set the Y texture map dimension.  
\item {\ttfamily obj.\-Set\-Thickness (int )} -\/ Set the thickness of the \char`\"{}on\char`\"{} region.  
\item {\ttfamily int = obj.\-Get\-Thickness ()} -\/ Set the thickness of the \char`\"{}on\char`\"{} region.  
\item {\ttfamily obj.\-Set\-In\-In (char , char )} -\/ Specify intensity/transparency for \char`\"{}in/in\char`\"{} region.  
\item {\ttfamily obj.\-Set\-In\-In (char a\mbox{[}2\mbox{]})} -\/ Specify intensity/transparency for \char`\"{}in/in\char`\"{} region.  
\item {\ttfamily char = obj. Get\-In\-In ()} -\/ Specify intensity/transparency for \char`\"{}in/in\char`\"{} region.  
\item {\ttfamily obj.\-Set\-In\-Out (char , char )} -\/ Specify intensity/transparency for \char`\"{}in/out\char`\"{} region.  
\item {\ttfamily obj.\-Set\-In\-Out (char a\mbox{[}2\mbox{]})} -\/ Specify intensity/transparency for \char`\"{}in/out\char`\"{} region.  
\item {\ttfamily char = obj. Get\-In\-Out ()} -\/ Specify intensity/transparency for \char`\"{}in/out\char`\"{} region.  
\item {\ttfamily obj.\-Set\-Out\-In (char , char )} -\/ Specify intensity/transparency for \char`\"{}out/in\char`\"{} region.  
\item {\ttfamily obj.\-Set\-Out\-In (char a\mbox{[}2\mbox{]})} -\/ Specify intensity/transparency for \char`\"{}out/in\char`\"{} region.  
\item {\ttfamily char = obj. Get\-Out\-In ()} -\/ Specify intensity/transparency for \char`\"{}out/in\char`\"{} region.  
\item {\ttfamily obj.\-Set\-Out\-Out (char , char )} -\/ Specify intensity/transparency for \char`\"{}out/out\char`\"{} region.  
\item {\ttfamily obj.\-Set\-Out\-Out (char a\mbox{[}2\mbox{]})} -\/ Specify intensity/transparency for \char`\"{}out/out\char`\"{} region.  
\item {\ttfamily char = obj. Get\-Out\-Out ()} -\/ Specify intensity/transparency for \char`\"{}out/out\char`\"{} region.  
\item {\ttfamily obj.\-Set\-On\-On (char , char )} -\/ Specify intensity/transparency for \char`\"{}on/on\char`\"{} region.  
\item {\ttfamily obj.\-Set\-On\-On (char a\mbox{[}2\mbox{]})} -\/ Specify intensity/transparency for \char`\"{}on/on\char`\"{} region.  
\item {\ttfamily char = obj. Get\-On\-On ()} -\/ Specify intensity/transparency for \char`\"{}on/on\char`\"{} region.  
\item {\ttfamily obj.\-Set\-On\-In (char , char )} -\/ Specify intensity/transparency for \char`\"{}on/in\char`\"{} region.  
\item {\ttfamily obj.\-Set\-On\-In (char a\mbox{[}2\mbox{]})} -\/ Specify intensity/transparency for \char`\"{}on/in\char`\"{} region.  
\item {\ttfamily char = obj. Get\-On\-In ()} -\/ Specify intensity/transparency for \char`\"{}on/in\char`\"{} region.  
\item {\ttfamily obj.\-Set\-On\-Out (char , char )} -\/ Specify intensity/transparency for \char`\"{}on/out\char`\"{} region.  
\item {\ttfamily obj.\-Set\-On\-Out (char a\mbox{[}2\mbox{]})} -\/ Specify intensity/transparency for \char`\"{}on/out\char`\"{} region.  
\item {\ttfamily char = obj. Get\-On\-Out ()} -\/ Specify intensity/transparency for \char`\"{}on/out\char`\"{} region.  
\item {\ttfamily obj.\-Set\-In\-On (char , char )} -\/ Specify intensity/transparency for \char`\"{}in/on\char`\"{} region.  
\item {\ttfamily obj.\-Set\-In\-On (char a\mbox{[}2\mbox{]})} -\/ Specify intensity/transparency for \char`\"{}in/on\char`\"{} region.  
\item {\ttfamily char = obj. Get\-In\-On ()} -\/ Specify intensity/transparency for \char`\"{}in/on\char`\"{} region.  
\item {\ttfamily obj.\-Set\-Out\-On (char , char )} -\/ Specify intensity/transparency for \char`\"{}out/on\char`\"{} region.  
\item {\ttfamily obj.\-Set\-Out\-On (char a\mbox{[}2\mbox{]})} -\/ Specify intensity/transparency for \char`\"{}out/on\char`\"{} region.  
\item {\ttfamily char = obj. Get\-Out\-On ()} -\/ Specify intensity/transparency for \char`\"{}out/on\char`\"{} region.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkextractvoi}{}\section{vtk\-Extract\-V\-O\-I}\label{vtkimaging_vtkextractvoi}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Extract\-V\-O\-I is a filter that selects a portion of an input structured points 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 points 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 slice from a volume for image processing, subsampling large volumes to reduce data size, or extracting regions of a volume with interesting data.

To create an instance of class vtk\-Extract\-V\-O\-I, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExtractVOI
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Extract\-V\-O\-I has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-V\-O\-I class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Extract\-V\-O\-I = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Extract\-V\-O\-I = 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 points dataset can be of any topological dimension (i.\-e., point, line, image, or volume).  
\item {\ttfamily obj.\-Set\-V\-O\-I (int a\mbox{[}6\mbox{]})} -\/ Specify i-\/j-\/k (min,max) pairs to extract. The resulting structured points dataset can be of any topological dimension (i.\-e., point, line, image, or volume).  
\item {\ttfamily int = obj. Get\-V\-O\-I ()} -\/ Specify i-\/j-\/k (min,max) pairs to extract. The resulting structured points dataset can be of any topological dimension (i.\-e., point, line, image, or volume).  
\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.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkfastsplatter}{}\section{vtk\-Fast\-Splatter}\label{vtkimaging_vtkfastsplatter}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Fast\-Splatter takes any vtk\-Point\-Set as input (of which vtk\-Poly\-Data and vtk\-Unstructured\-Grid inherit). Each point in the data set is considered to be an impulse. These impulses are convolved with a given splat image. In other words, the splat image is added to the final image at every place where there is an input point.

Note that point and cell data are thrown away. If you want a sampling of unstructured points consider vtk\-Gaussian\-Splatter or vtk\-Shepard\-Method.

Use input port 0 for the impulse data (vtk\-Point\-Set), and input port 1 for the splat image (vtk\-Image\-Data)

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

Any point outside of the extents of the image is thrown away, even if it is close enough such that it's convolution with the splat image would overlap the extents.

To create an instance of class vtk\-Fast\-Splatter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFastSplatter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Fast\-Splatter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Fast\-Splatter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Fast\-Splatter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Fast\-Splatter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Model\-Bounds (double , double , double , double , double , double )} -\/ Set / get the (xmin,xmax, ymin,ymax, zmin,zmax) bounding box in which the sampling is performed. If any of the (min,max) bounds values are min $>$= max, then the bounds will be computed automatically from the input data. Otherwise, the user-\/specified bounds will be used.  
\item {\ttfamily obj.\-Set\-Model\-Bounds (double a\mbox{[}6\mbox{]})} -\/ Set / get the (xmin,xmax, ymin,ymax, zmin,zmax) bounding box in which the sampling is performed. If any of the (min,max) bounds values are min $>$= max, then the bounds will be computed automatically from the input data. Otherwise, the user-\/specified bounds will be used.  
\item {\ttfamily double = obj. Get\-Model\-Bounds ()} -\/ Set / get the (xmin,xmax, ymin,ymax, zmin,zmax) bounding box in which the sampling is performed. If any of the (min,max) bounds values are min $>$= max, then the bounds will be computed automatically from the input data. Otherwise, the user-\/specified bounds will be used.  
\item {\ttfamily obj.\-Set\-Output\-Dimensions (int , int , int )} -\/ Set/get the dimensions of the output image  
\item {\ttfamily obj.\-Set\-Output\-Dimensions (int a\mbox{[}3\mbox{]})} -\/ Set/get the dimensions of the output image  
\item {\ttfamily int = obj. Get\-Output\-Dimensions ()} -\/ Set/get the dimensions of the output image  
\item {\ttfamily obj.\-Set\-Limit\-Mode (int )} -\/ Set/get the way voxel values will be limited. If this is set to None (the default), the output can have arbitrarily large values. If set to clamp, the output will be clamped to \mbox{[}Min\-Value,Max\-Value\mbox{]}. If set to scale, the output will be linearly scaled between Min\-Value and Max\-Value.  
\item {\ttfamily int = obj.\-Get\-Limit\-Mode ()} -\/ Set/get the way voxel values will be limited. If this is set to None (the default), the output can have arbitrarily large values. If set to clamp, the output will be clamped to \mbox{[}Min\-Value,Max\-Value\mbox{]}. If set to scale, the output will be linearly scaled between Min\-Value and Max\-Value.  
\item {\ttfamily obj.\-Set\-Limit\-Mode\-To\-None ()} -\/ Set/get the way voxel values will be limited. If this is set to None (the default), the output can have arbitrarily large values. If set to clamp, the output will be clamped to \mbox{[}Min\-Value,Max\-Value\mbox{]}. If set to scale, the output will be linearly scaled between Min\-Value and Max\-Value.  
\item {\ttfamily obj.\-Set\-Limit\-Mode\-To\-Clamp ()} -\/ Set/get the way voxel values will be limited. If this is set to None (the default), the output can have arbitrarily large values. If set to clamp, the output will be clamped to \mbox{[}Min\-Value,Max\-Value\mbox{]}. If set to scale, the output will be linearly scaled between Min\-Value and Max\-Value.  
\item {\ttfamily obj.\-Set\-Limit\-Mode\-To\-Scale ()} -\/ Set/get the way voxel values will be limited. If this is set to None (the default), the output can have arbitrarily large values. If set to clamp, the output will be clamped to \mbox{[}Min\-Value,Max\-Value\mbox{]}. If set to scale, the output will be linearly scaled between Min\-Value and Max\-Value.  
\item {\ttfamily obj.\-Set\-Limit\-Mode\-To\-Freeze\-Scale ()} -\/ See the Limit\-Mode method.  
\item {\ttfamily obj.\-Set\-Min\-Value (double )} -\/ See the Limit\-Mode method.  
\item {\ttfamily double = obj.\-Get\-Min\-Value ()} -\/ See the Limit\-Mode method.  
\item {\ttfamily obj.\-Set\-Max\-Value (double )} -\/ See the Limit\-Mode method.  
\item {\ttfamily double = obj.\-Get\-Max\-Value ()} -\/ See the Limit\-Mode method.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Points\-Splatted ()} -\/ This returns the number of points splatted (as opposed to discarded for being outside the image) during the previous pass.  
\item {\ttfamily obj.\-Set\-Splat\-Connection (vtk\-Algorithm\-Output )} -\/ Convenience function for connecting the splat algorithm source. This is provided mainly for convenience using the filter with Para\-View, V\-T\-K users should prefer Set\-Input\-Connection(1, splat) instead.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkgaussiansplatter}{}\section{vtk\-Gaussian\-Splatter}\label{vtkimaging_vtkgaussiansplatter}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Gaussian\-Splatter is a filter that injects input points into a structured points (volume) dataset. As each point is injected, it \char`\"{}splats\char`\"{} or distributes values to nearby voxels. Data is distributed using an elliptical, Gaussian distribution function. The distribution function is modified using scalar values (expands distribution) or normals (creates ellipsoidal distribution rather than spherical).

In general, the Gaussian distribution function f(x) around a given splat point p is given by \begin{DoxyVerb}f(x) = ScaleFactor * exp( ExponentFactor*((r/Radius)**2) )
\end{DoxyVerb}


where x is the current voxel sample point; r is the distance $|$x-\/p$|$ Exponent\-Factor $<$= 0.\-0, and Scale\-Factor can be multiplied by the scalar value of the point p that is currently being splatted.

If points normals are present (and Normal\-Warping is on), then the splat function becomes elliptical (as compared to the spherical one described by the previous equation). The Gaussian distribution function then becomes\-: \begin{DoxyVerb}f(x) = ScaleFactor * 
          exp( ExponentFactor*( ((rxy/E)**2 + z**2)/R**2) )
\end{DoxyVerb}


where E is a user-\/defined eccentricity factor that controls the elliptical shape of the splat; z is the distance of the current voxel sample point along normal N; and rxy is the distance of x in the direction prependicular to N.

This class is typically used to convert point-\/valued distributions into a volume representation. The volume is then usually iso-\/surfaced or volume rendered to generate a visualization. It can be used to create surfaces from point distributions, or to create structure (i.\-e., topology) when none exists.

To create an instance of class vtk\-Gaussian\-Splatter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGaussianSplatter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Gaussian\-Splatter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Gaussian\-Splatter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Gaussian\-Splatter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Gaussian\-Splatter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Sample\-Dimensions (int i, int j, int k)} -\/ Set / get the dimensions of the sampling structured point set. Higher values produce better results but are much slower.  
\item {\ttfamily obj.\-Set\-Sample\-Dimensions (int dim\mbox{[}3\mbox{]})} -\/ Set / get the dimensions of the sampling structured point set. Higher values produce better results but are much slower.  
\item {\ttfamily int = obj. Get\-Sample\-Dimensions ()} -\/ Set / get the dimensions of the sampling structured point set. Higher values produce better results but are much slower.  
\item {\ttfamily obj.\-Set\-Model\-Bounds (double , double , double , double , double , double )} -\/ Set / get the (xmin,xmax, ymin,ymax, zmin,zmax) bounding box in which the sampling is performed. If any of the (min,max) bounds values are min $>$= max, then the bounds will be computed automatically from the input data. Otherwise, the user-\/specified bounds will be used.  
\item {\ttfamily obj.\-Set\-Model\-Bounds (double a\mbox{[}6\mbox{]})} -\/ Set / get the (xmin,xmax, ymin,ymax, zmin,zmax) bounding box in which the sampling is performed. If any of the (min,max) bounds values are min $>$= max, then the bounds will be computed automatically from the input data. Otherwise, the user-\/specified bounds will be used.  
\item {\ttfamily double = obj. Get\-Model\-Bounds ()} -\/ Set / get the (xmin,xmax, ymin,ymax, zmin,zmax) bounding box in which the sampling is performed. If any of the (min,max) bounds values are min $>$= max, then the bounds will be computed automatically from the input data. Otherwise, the user-\/specified bounds will be used.  
\item {\ttfamily obj.\-Set\-Radius (double )} -\/ Set / get the radius of propagation of the splat. This value is expressed as a percentage of the length of the longest side of the sampling volume. Smaller numbers greatly reduce execution time.  
\item {\ttfamily double = obj.\-Get\-Radius\-Min\-Value ()} -\/ Set / get the radius of propagation of the splat. This value is expressed as a percentage of the length of the longest side of the sampling volume. Smaller numbers greatly reduce execution time.  
\item {\ttfamily double = obj.\-Get\-Radius\-Max\-Value ()} -\/ Set / get the radius of propagation of the splat. This value is expressed as a percentage of the length of the longest side of the sampling volume. Smaller numbers greatly reduce execution time.  
\item {\ttfamily double = obj.\-Get\-Radius ()} -\/ Set / get the radius of propagation of the splat. This value is expressed as a percentage of the length of the longest side of the sampling volume. Smaller numbers greatly reduce execution time.  
\item {\ttfamily obj.\-Set\-Scale\-Factor (double )} -\/ Multiply Gaussian splat distribution by this value. If Scalar\-Warping is on, then the Scalar value will be multiplied by the Scale\-Factor times the Gaussian function.  
\item {\ttfamily double = obj.\-Get\-Scale\-Factor\-Min\-Value ()} -\/ Multiply Gaussian splat distribution by this value. If Scalar\-Warping is on, then the Scalar value will be multiplied by the Scale\-Factor times the Gaussian function.  
\item {\ttfamily double = obj.\-Get\-Scale\-Factor\-Max\-Value ()} -\/ Multiply Gaussian splat distribution by this value. If Scalar\-Warping is on, then the Scalar value will be multiplied by the Scale\-Factor times the Gaussian function.  
\item {\ttfamily double = obj.\-Get\-Scale\-Factor ()} -\/ Multiply Gaussian splat distribution by this value. If Scalar\-Warping is on, then the Scalar value will be multiplied by the Scale\-Factor times the Gaussian function.  
\item {\ttfamily obj.\-Set\-Exponent\-Factor (double )} -\/ Set / get the sharpness of decay of the splats. This is the exponent constant in the Gaussian equation. Normally this is a negative value.  
\item {\ttfamily double = obj.\-Get\-Exponent\-Factor ()} -\/ Set / get the sharpness of decay of the splats. This is the exponent constant in the Gaussian equation. Normally this is a negative value.  
\item {\ttfamily obj.\-Set\-Normal\-Warping (int )} -\/ Turn on/off the generation of elliptical splats. If normal warping is on, then the input normals affect the distribution of the splat. This boolean is used in combination with the Eccentricity ivar.  
\item {\ttfamily int = obj.\-Get\-Normal\-Warping ()} -\/ Turn on/off the generation of elliptical splats. If normal warping is on, then the input normals affect the distribution of the splat. This boolean is used in combination with the Eccentricity ivar.  
\item {\ttfamily obj.\-Normal\-Warping\-On ()} -\/ Turn on/off the generation of elliptical splats. If normal warping is on, then the input normals affect the distribution of the splat. This boolean is used in combination with the Eccentricity ivar.  
\item {\ttfamily obj.\-Normal\-Warping\-Off ()} -\/ Turn on/off the generation of elliptical splats. If normal warping is on, then the input normals affect the distribution of the splat. This boolean is used in combination with the Eccentricity ivar.  
\item {\ttfamily obj.\-Set\-Eccentricity (double )} -\/ Control the shape of elliptical splatting. Eccentricity is the ratio of the major axis (aligned along normal) to the minor (axes) aligned along other two axes. So Eccentricity $>$ 1 creates needles with the long axis in the direction of the normal; Eccentricity$<$1 creates pancakes perpendicular to the normal vector.  
\item {\ttfamily double = obj.\-Get\-Eccentricity\-Min\-Value ()} -\/ Control the shape of elliptical splatting. Eccentricity is the ratio of the major axis (aligned along normal) to the minor (axes) aligned along other two axes. So Eccentricity $>$ 1 creates needles with the long axis in the direction of the normal; Eccentricity$<$1 creates pancakes perpendicular to the normal vector.  
\item {\ttfamily double = obj.\-Get\-Eccentricity\-Max\-Value ()} -\/ Control the shape of elliptical splatting. Eccentricity is the ratio of the major axis (aligned along normal) to the minor (axes) aligned along other two axes. So Eccentricity $>$ 1 creates needles with the long axis in the direction of the normal; Eccentricity$<$1 creates pancakes perpendicular to the normal vector.  
\item {\ttfamily double = obj.\-Get\-Eccentricity ()} -\/ Control the shape of elliptical splatting. Eccentricity is the ratio of the major axis (aligned along normal) to the minor (axes) aligned along other two axes. So Eccentricity $>$ 1 creates needles with the long axis in the direction of the normal; Eccentricity$<$1 creates pancakes perpendicular to the normal vector.  
\item {\ttfamily obj.\-Set\-Scalar\-Warping (int )} -\/ Turn on/off the scaling of splats by scalar value.  
\item {\ttfamily int = obj.\-Get\-Scalar\-Warping ()} -\/ Turn on/off the scaling of splats by scalar value.  
\item {\ttfamily obj.\-Scalar\-Warping\-On ()} -\/ Turn on/off the scaling of splats by scalar value.  
\item {\ttfamily obj.\-Scalar\-Warping\-Off ()} -\/ Turn on/off the scaling of splats by scalar value.  
\item {\ttfamily obj.\-Set\-Capping (int )} -\/ Turn on/off the capping of the outer boundary of the volume to a specified cap value. This can be used to close surfaces (after iso-\/surfacing) and create other effects.  
\item {\ttfamily int = obj.\-Get\-Capping ()} -\/ Turn on/off the capping of the outer boundary of the volume to a specified cap value. This can be used to close surfaces (after iso-\/surfacing) and create other effects.  
\item {\ttfamily obj.\-Capping\-On ()} -\/ Turn on/off the capping of the outer boundary of the volume to a specified cap value. This can be used to close surfaces (after iso-\/surfacing) and create other effects.  
\item {\ttfamily obj.\-Capping\-Off ()} -\/ Turn on/off the capping of the outer boundary of the volume to a specified cap value. This can be used to close surfaces (after iso-\/surfacing) and create other effects.  
\item {\ttfamily obj.\-Set\-Cap\-Value (double )} -\/ Specify the cap value to use. (This instance variable only has effect if the ivar Capping is on.)  
\item {\ttfamily double = obj.\-Get\-Cap\-Value ()} -\/ Specify the cap value to use. (This instance variable only has effect if the ivar Capping is on.)  
\item {\ttfamily obj.\-Set\-Accumulation\-Mode (int )} -\/ Specify the scalar accumulation mode. This mode expresses how scalar values are combined when splats are overlapped. The Max mode acts like a set union operation and is the most commonly used; the Min mode acts like a set intersection, and the sum is just weird.  
\item {\ttfamily int = obj.\-Get\-Accumulation\-Mode\-Min\-Value ()} -\/ Specify the scalar accumulation mode. This mode expresses how scalar values are combined when splats are overlapped. The Max mode acts like a set union operation and is the most commonly used; the Min mode acts like a set intersection, and the sum is just weird.  
\item {\ttfamily int = obj.\-Get\-Accumulation\-Mode\-Max\-Value ()} -\/ Specify the scalar accumulation mode. This mode expresses how scalar values are combined when splats are overlapped. The Max mode acts like a set union operation and is the most commonly used; the Min mode acts like a set intersection, and the sum is just weird.  
\item {\ttfamily int = obj.\-Get\-Accumulation\-Mode ()} -\/ Specify the scalar accumulation mode. This mode expresses how scalar values are combined when splats are overlapped. The Max mode acts like a set union operation and is the most commonly used; the Min mode acts like a set intersection, and the sum is just weird.  
\item {\ttfamily obj.\-Set\-Accumulation\-Mode\-To\-Min ()} -\/ Specify the scalar accumulation mode. This mode expresses how scalar values are combined when splats are overlapped. The Max mode acts like a set union operation and is the most commonly used; the Min mode acts like a set intersection, and the sum is just weird.  
\item {\ttfamily obj.\-Set\-Accumulation\-Mode\-To\-Max ()} -\/ Specify the scalar accumulation mode. This mode expresses how scalar values are combined when splats are overlapped. The Max mode acts like a set union operation and is the most commonly used; the Min mode acts like a set intersection, and the sum is just weird.  
\item {\ttfamily obj.\-Set\-Accumulation\-Mode\-To\-Sum ()} -\/ Specify the scalar accumulation mode. This mode expresses how scalar values are combined when splats are overlapped. The Max mode acts like a set union operation and is the most commonly used; the Min mode acts like a set intersection, and the sum is just weird.  
\item {\ttfamily string = obj.\-Get\-Accumulation\-Mode\-As\-String ()} -\/ Specify the scalar accumulation mode. This mode expresses how scalar values are combined when splats are overlapped. The Max mode acts like a set union operation and is the most commonly used; the Min mode acts like a set intersection, and the sum is just weird.  
\item {\ttfamily obj.\-Set\-Null\-Value (double )} -\/ Set the Null value for output points not receiving a contribution from the input points. (This is the initial value of the voxel samples.)  
\item {\ttfamily double = obj.\-Get\-Null\-Value ()} -\/ Set the Null value for output points not receiving a contribution from the input points. (This is the initial value of the voxel samples.)  
\item {\ttfamily obj.\-Compute\-Model\-Bounds (vtk\-Data\-Set input, vtk\-Image\-Data output, vtk\-Information out\-Info)} -\/ Compute the size of the sample bounding box automatically from the input data. This is an internal helper function.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageaccumulate}{}\section{vtk\-Image\-Accumulate}\label{vtkimaging_vtkimageaccumulate}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Accumulate -\/ This filter divides component space into discrete bins. It then counts the number of pixels associated with each bin. The output is this \char`\"{}scatter plot\char`\"{} (histogram values for 1\-D). The dimensionality of the output depends on how many components the input pixels have. Input pixels with one component generate a 1\-D histogram. This filter can only handle images with 1 to 3 scalar components. The input can be any type, but the output is always int. Some statistics are computed on the pixel values at the same time. The Set\-Stencil and Reverse\-Stencil functions allow the statistics to be computed on an arbitrary portion of the input data. See the documentation for vtk\-Image\-Stencil\-Data for more information.

This filter also support ignoring pixel with value equal to 0. Using this option with vtk\-Image\-Mask may result in results being slightly off since 0 could be a valid value from your input.

To create an instance of class vtk\-Image\-Accumulate, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageAccumulate
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Accumulate has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Accumulate class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Accumulate = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Accumulate = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Component\-Spacing (double , double , double )} -\/ Set/\-Get -\/ The component spacing is the dimension of each bin. This ends up being the spacing of the output \char`\"{}image\char`\"{}. If the number of input scalar components are less than three, then some of these spacing values are ignored. For a 1\-D histogram with 10 bins spanning the values 1000 to 2000, this spacing should be set to 100, 0, 0  
\item {\ttfamily obj.\-Set\-Component\-Spacing (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get -\/ The component spacing is the dimension of each bin. This ends up being the spacing of the output \char`\"{}image\char`\"{}. If the number of input scalar components are less than three, then some of these spacing values are ignored. For a 1\-D histogram with 10 bins spanning the values 1000 to 2000, this spacing should be set to 100, 0, 0  
\item {\ttfamily double = obj. Get\-Component\-Spacing ()} -\/ Set/\-Get -\/ The component spacing is the dimension of each bin. This ends up being the spacing of the output \char`\"{}image\char`\"{}. If the number of input scalar components are less than three, then some of these spacing values are ignored. For a 1\-D histogram with 10 bins spanning the values 1000 to 2000, this spacing should be set to 100, 0, 0  
\item {\ttfamily obj.\-Set\-Component\-Origin (double , double , double )} -\/ Set/\-Get -\/ The component origin is the location of bin (0, 0, 0). Note that if the Component extent does not include the value (0,0,0), then this origin bin will not actually be in the output. The origin of the output ends up being the same as the componenet origin. For a 1\-D histogram with 10 bins spanning the values 1000 to 2000, this origin should be set to 1000, 0, 0  
\item {\ttfamily obj.\-Set\-Component\-Origin (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get -\/ The component origin is the location of bin (0, 0, 0). Note that if the Component extent does not include the value (0,0,0), then this origin bin will not actually be in the output. The origin of the output ends up being the same as the componenet origin. For a 1\-D histogram with 10 bins spanning the values 1000 to 2000, this origin should be set to 1000, 0, 0  
\item {\ttfamily double = obj. Get\-Component\-Origin ()} -\/ Set/\-Get -\/ The component origin is the location of bin (0, 0, 0). Note that if the Component extent does not include the value (0,0,0), then this origin bin will not actually be in the output. The origin of the output ends up being the same as the componenet origin. For a 1\-D histogram with 10 bins spanning the values 1000 to 2000, this origin should be set to 1000, 0, 0  
\item {\ttfamily obj.\-Set\-Component\-Extent (int extent\mbox{[}6\mbox{]})} -\/ Set/\-Get -\/ The component extent sets the number/extent of the bins. For a 1\-D histogram with 10 bins spanning the values 1000 to 2000, this extent should be set to 0, 9, 0, 0, 0, 0. The extent specifies inclusive min/max values. This implies that the top extent should be set to the number of bins -\/ 1.  
\item {\ttfamily obj.\-Set\-Component\-Extent (int min\-X, int max\-X, int min\-Y, int max\-Y, int min\-Z, int max\-Z)} -\/ Set/\-Get -\/ The component extent sets the number/extent of the bins. For a 1\-D histogram with 10 bins spanning the values 1000 to 2000, this extent should be set to 0, 9, 0, 0, 0, 0. The extent specifies inclusive min/max values. This implies that the top extent should be set to the number of bins -\/ 1.  
\item {\ttfamily obj.\-Get\-Component\-Extent (int extent\mbox{[}6\mbox{]})} -\/ Set/\-Get -\/ The component extent sets the number/extent of the bins. For a 1\-D histogram with 10 bins spanning the values 1000 to 2000, this extent should be set to 0, 9, 0, 0, 0, 0. The extent specifies inclusive min/max values. This implies that the top extent should be set to the number of bins -\/ 1.  
\item {\ttfamily int = obj.\-Get\-Component\-Extent ()} -\/ Use a stencil to specify which voxels to accumulate.  
\item {\ttfamily obj.\-Set\-Stencil (vtk\-Image\-Stencil\-Data stencil)} -\/ Use a stencil to specify which voxels to accumulate.  
\item {\ttfamily vtk\-Image\-Stencil\-Data = obj.\-Get\-Stencil ()} -\/ Use a stencil to specify which voxels to accumulate.  
\item {\ttfamily obj.\-Set\-Reverse\-Stencil (int )} -\/ Reverse the stencil.  
\item {\ttfamily int = obj.\-Get\-Reverse\-Stencil\-Min\-Value ()} -\/ Reverse the stencil.  
\item {\ttfamily int = obj.\-Get\-Reverse\-Stencil\-Max\-Value ()} -\/ Reverse the stencil.  
\item {\ttfamily obj.\-Reverse\-Stencil\-On ()} -\/ Reverse the stencil.  
\item {\ttfamily obj.\-Reverse\-Stencil\-Off ()} -\/ Reverse the stencil.  
\item {\ttfamily int = obj.\-Get\-Reverse\-Stencil ()} -\/ Reverse the stencil.  
\item {\ttfamily double = obj. Get\-Min ()} -\/ Get the statistics information for the data.  
\item {\ttfamily double = obj. Get\-Max ()} -\/ Get the statistics information for the data.  
\item {\ttfamily double = obj. Get\-Mean ()} -\/ Get the statistics information for the data.  
\item {\ttfamily double = obj. Get\-Standard\-Deviation ()} -\/ Get the statistics information for the data.  
\item {\ttfamily long = obj.\-Get\-Voxel\-Count ()} -\/ Get the statistics information for the data.  
\item {\ttfamily obj.\-Set\-Ignore\-Zero (int )} -\/ Should the data with value 0 be ignored?  
\item {\ttfamily int = obj.\-Get\-Ignore\-Zero\-Min\-Value ()} -\/ Should the data with value 0 be ignored?  
\item {\ttfamily int = obj.\-Get\-Ignore\-Zero\-Max\-Value ()} -\/ Should the data with value 0 be ignored?  
\item {\ttfamily int = obj.\-Get\-Ignore\-Zero ()} -\/ Should the data with value 0 be ignored?  
\item {\ttfamily obj.\-Ignore\-Zero\-On ()} -\/ Should the data with value 0 be ignored?  
\item {\ttfamily obj.\-Ignore\-Zero\-Off ()} -\/ Should the data with value 0 be ignored?  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageanisotropicdiffusion2d}{}\section{vtk\-Image\-Anisotropic\-Diffusion2\-D}\label{vtkimaging_vtkimageanisotropicdiffusion2d}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Anisotropic\-Diffusion2\-D diffuses a 2d image iteratively. The neighborhood of the diffusion is determined by the instance flags. If \char`\"{}\-Edges\char`\"{} is on the 4 edge connected voxels are included, and if \char`\"{}\-Corners\char`\"{} is on, the 4 corner connected voxels are included. \char`\"{}\-Diffusion\-Factor\char`\"{} determines how far a pixel value moves toward its neighbors, and is insensitive to the number of neighbors chosen. The diffusion is anisotropic because it only occurs when a gradient measure is below \char`\"{}\-Gradient\-Threshold\char`\"{}. Two gradient measures exist and are toggled by the \char`\"{}\-Gradient\-Magnitude\-Threshold\char`\"{} flag. When \char`\"{}\-Gradient\-Magnitude\-Threshold\char`\"{} is on, the magnitude of the gradient, computed by central differences, above \char`\"{}\-Diffusion\-Threshold\char`\"{} a voxel is not modified. The alternative measure examines each neighbor independently. The gradient between the voxel and the neighbor must be below the \char`\"{}\-Diffusion\-Threshold\char`\"{} for diffusion to occur with T\-H\-A\-T neighbor.

To create an instance of class vtk\-Image\-Anisotropic\-Diffusion2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageAnisotropicDiffusion2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Anisotropic\-Diffusion2\-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\-Image\-Anisotropic\-Diffusion2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Anisotropic\-Diffusion2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Anisotropic\-Diffusion2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Number\-Of\-Iterations (int num)} -\/ This method sets the number of interations which also affects the input neighborhood needed to compute one output pixel. Each iterations requires an extra pixel layer on the neighborhood. This is only relavent when you are trying to stream or are requesting a sub extent of the \char`\"{}whole\-Extent\char`\"{}.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Iterations ()} -\/ Get the number of iterations.  
\item {\ttfamily obj.\-Set\-Diffusion\-Threshold (double )} -\/ Set/\-Get the difference threshold that stops diffusion. when the difference between two pixel is greater than this threshold, the pixels are not diffused. This causes diffusion to avoid sharp edges. If the Gradient\-Magnitude\-Threshold is set, then gradient magnitude is used for comparison instead of pixel differences.  
\item {\ttfamily double = obj.\-Get\-Diffusion\-Threshold ()} -\/ Set/\-Get the difference threshold that stops diffusion. when the difference between two pixel is greater than this threshold, the pixels are not diffused. This causes diffusion to avoid sharp edges. If the Gradient\-Magnitude\-Threshold is set, then gradient magnitude is used for comparison instead of pixel differences.  
\item {\ttfamily obj.\-Set\-Diffusion\-Factor (double )} -\/ The diffusion factor specifies how much neighboring pixels effect each other. No diffusion occurs with a factor of 0, and a diffusion factor of 1 causes the pixel to become the average of all its neighbors.  
\item {\ttfamily double = obj.\-Get\-Diffusion\-Factor ()} -\/ The diffusion factor specifies how much neighboring pixels effect each other. No diffusion occurs with a factor of 0, and a diffusion factor of 1 causes the pixel to become the average of all its neighbors.  
\item {\ttfamily obj.\-Set\-Faces (int )} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily int = obj.\-Get\-Faces ()} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily obj.\-Faces\-On ()} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily obj.\-Faces\-Off ()} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily obj.\-Set\-Edges (int )} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily int = obj.\-Get\-Edges ()} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily obj.\-Edges\-On ()} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily obj.\-Edges\-Off ()} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily obj.\-Set\-Corners (int )} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily int = obj.\-Get\-Corners ()} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily obj.\-Corners\-On ()} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily obj.\-Corners\-Off ()} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily obj.\-Set\-Gradient\-Magnitude\-Threshold (int )} -\/ Switch between gradient magnitude threshold and pixel gradient threshold.  
\item {\ttfamily int = obj.\-Get\-Gradient\-Magnitude\-Threshold ()} -\/ Switch between gradient magnitude threshold and pixel gradient threshold.  
\item {\ttfamily obj.\-Gradient\-Magnitude\-Threshold\-On ()} -\/ Switch between gradient magnitude threshold and pixel gradient threshold.  
\item {\ttfamily obj.\-Gradient\-Magnitude\-Threshold\-Off ()} -\/ Switch between gradient magnitude threshold and pixel gradient threshold.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageanisotropicdiffusion3d}{}\section{vtk\-Image\-Anisotropic\-Diffusion3\-D}\label{vtkimaging_vtkimageanisotropicdiffusion3d}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Anisotropic\-Diffusion3\-D diffuses an volume iteratively. The neighborhood of the diffusion is determined by the instance flags. if \char`\"{}\-Faces\char`\"{} is on, the 6 voxels adjoined by faces are included in the neighborhood. If \char`\"{}\-Edges\char`\"{} is on the 12 edge connected voxels are included, and if \char`\"{}\-Corners\char`\"{} is on, the 8 corner connected voxels are included. \char`\"{}\-Diffusion\-Factor\char`\"{} determines how far a pixel value moves toward its neighbors, and is insensitive to the number of neighbors chosen. The diffusion is anisotropic because it only occurs when a gradient measure is below \char`\"{}\-Gradient\-Threshold\char`\"{}. Two gradient measures exist and are toggled by the \char`\"{}\-Gradient\-Magnitude\-Threshold\char`\"{} flag. When \char`\"{}\-Gradient\-Magnitude\-Threshold\char`\"{} is on, the magnitude of the gradient, computed by central differences, above \char`\"{}\-Diffusion\-Threshold\char`\"{} a voxel is not modified. The alternative measure examines each neighbor independently. The gradient between the voxel and the neighbor must be below the \char`\"{}\-Diffusion\-Threshold\char`\"{} for diffusion to occur with T\-H\-A\-T neighbor.

To create an instance of class vtk\-Image\-Anisotropic\-Diffusion3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageAnisotropicDiffusion3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Anisotropic\-Diffusion3\-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\-Image\-Anisotropic\-Diffusion3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Anisotropic\-Diffusion3\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Anisotropic\-Diffusion3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Number\-Of\-Iterations (int num)} -\/ This method sets the number of interations which also affects the input neighborhood needed to compute one output pixel. Each iterations requires an extra pixel layer on the neighborhood. This is only relavent when you are trying to stream or are requesting a sub extent of the \char`\"{}whole\-Extent\char`\"{}.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Iterations ()} -\/ Get the number of iterations.  
\item {\ttfamily obj.\-Set\-Diffusion\-Threshold (double )} -\/ Set/\-Get the difference threshold that stops diffusion. when the difference between two pixel is greater than this threshold, the pixels are not diffused. This causes diffusion to avoid sharp edges. If the Gradient\-Magnitude\-Threshold is set, then gradient magnitude is used for comparison instead of pixel differences.  
\item {\ttfamily double = obj.\-Get\-Diffusion\-Threshold ()} -\/ Set/\-Get the difference threshold that stops diffusion. when the difference between two pixel is greater than this threshold, the pixels are not diffused. This causes diffusion to avoid sharp edges. If the Gradient\-Magnitude\-Threshold is set, then gradient magnitude is used for comparison instead of pixel differences.  
\item {\ttfamily obj.\-Set\-Diffusion\-Factor (double )} -\/ Set/\-Get the difference factor  
\item {\ttfamily double = obj.\-Get\-Diffusion\-Factor ()} -\/ Set/\-Get the difference factor  
\item {\ttfamily obj.\-Set\-Faces (int )} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily int = obj.\-Get\-Faces ()} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily obj.\-Faces\-On ()} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily obj.\-Faces\-Off ()} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily obj.\-Set\-Edges (int )} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily int = obj.\-Get\-Edges ()} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily obj.\-Edges\-On ()} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily obj.\-Edges\-Off ()} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily obj.\-Set\-Corners (int )} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily int = obj.\-Get\-Corners ()} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily obj.\-Corners\-On ()} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily obj.\-Corners\-Off ()} -\/ Choose neighbors to diffuse (6 faces, 12 edges, 8 corners).  
\item {\ttfamily obj.\-Set\-Gradient\-Magnitude\-Threshold (int )} -\/ Switch between gradient magnitude threshold and pixel gradient threshold.  
\item {\ttfamily int = obj.\-Get\-Gradient\-Magnitude\-Threshold ()} -\/ Switch between gradient magnitude threshold and pixel gradient threshold.  
\item {\ttfamily obj.\-Gradient\-Magnitude\-Threshold\-On ()} -\/ Switch between gradient magnitude threshold and pixel gradient threshold.  
\item {\ttfamily obj.\-Gradient\-Magnitude\-Threshold\-Off ()} -\/ Switch between gradient magnitude threshold and pixel gradient threshold.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageappend}{}\section{vtk\-Image\-Append}\label{vtkimaging_vtkimageappend}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Append takes the components from multiple inputs and merges them into one output. The output images are append along the \char`\"{}\-Append\-Axis\char`\"{}. Except for the append axis, all inputs must have the same extent. All inputs must have the same number of scalar components. A future extension might be to pad or clip inputs to have the same extent. The output has the same origin and spacing as the first input. The origin and spacing of all other inputs are ignored. All inputs must have the same scalar type.

To create an instance of class vtk\-Image\-Append, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageAppend
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Append has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Append class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Append = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Append = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Replace\-Nth\-Input\-Connection (int idx, vtk\-Algorithm\-Output input)} -\/ Replace one of the input connections with a new input. You can only replace input connections that you previously created with Add\-Input\-Connection() or, in the case of the first input, with Set\-Input\-Connection().  
\item {\ttfamily obj.\-Set\-Input (int num, vtk\-Data\-Object input)} -\/ Set an Input of this filter. This method is only for support of old-\/style pipeline connections. When writing new code you should use Set\-Input\-Connection(), Add\-Input\-Connection(), and Replace\-Nth\-Input\-Connection() instead.  
\item {\ttfamily obj.\-Set\-Input (vtk\-Data\-Object input)} -\/ Set an Input of this filter. This method is only for support of old-\/style pipeline connections. When writing new code you should use Set\-Input\-Connection(), Add\-Input\-Connection(), and Replace\-Nth\-Input\-Connection() instead.  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Input (int num)} -\/ Get one input to this filter. This method is only for support of old-\/style pipeline connections. When writing new code you should use vtk\-Algorithm\-::\-Get\-Input\-Connection(0, num).  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Input ()} -\/ Get one input to this filter. This method is only for support of old-\/style pipeline connections. When writing new code you should use vtk\-Algorithm\-::\-Get\-Input\-Connection(0, num).  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Inputs ()} -\/ Get the number of inputs to this filter. This method is only for support of old-\/style pipeline connections. When writing new code you should use vtk\-Algorithm\-::\-Get\-Number\-Of\-Input\-Connections(0).  
\item {\ttfamily obj.\-Set\-Append\-Axis (int )} -\/ This axis is expanded to hold the multiple images. The default Append\-Axis is the X axis. If you want to create a volue from a series of X\-Y images, then you should set the Append\-Axis to 2 (Z axis).  
\item {\ttfamily int = obj.\-Get\-Append\-Axis ()} -\/ This axis is expanded to hold the multiple images. The default Append\-Axis is the X axis. If you want to create a volue from a series of X\-Y images, then you should set the Append\-Axis to 2 (Z axis).  
\item {\ttfamily obj.\-Set\-Preserve\-Extents (int )} -\/ By default \char`\"{}\-Preserve\-Extents\char`\"{} is off and the append axis is used. When \char`\"{}\-Preseve\-Extents\char`\"{} is on, the extent of the inputs is used to place the image in the output. The whole extent of the output is the union of the input whole extents. Any portion of the output not covered by the inputs is set to zero. The origin and spacing is taken from the first input.  
\item {\ttfamily int = obj.\-Get\-Preserve\-Extents ()} -\/ By default \char`\"{}\-Preserve\-Extents\char`\"{} is off and the append axis is used. When \char`\"{}\-Preseve\-Extents\char`\"{} is on, the extent of the inputs is used to place the image in the output. The whole extent of the output is the union of the input whole extents. Any portion of the output not covered by the inputs is set to zero. The origin and spacing is taken from the first input.  
\item {\ttfamily obj.\-Preserve\-Extents\-On ()} -\/ By default \char`\"{}\-Preserve\-Extents\char`\"{} is off and the append axis is used. When \char`\"{}\-Preseve\-Extents\char`\"{} is on, the extent of the inputs is used to place the image in the output. The whole extent of the output is the union of the input whole extents. Any portion of the output not covered by the inputs is set to zero. The origin and spacing is taken from the first input.  
\item {\ttfamily obj.\-Preserve\-Extents\-Off ()} -\/ By default \char`\"{}\-Preserve\-Extents\char`\"{} is off and the append axis is used. When \char`\"{}\-Preseve\-Extents\char`\"{} is on, the extent of the inputs is used to place the image in the output. The whole extent of the output is the union of the input whole extents. Any portion of the output not covered by the inputs is set to zero. The origin and spacing is taken from the first input.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageappendcomponents}{}\section{vtk\-Image\-Append\-Components}\label{vtkimaging_vtkimageappendcomponents}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Append\-Components takes the components from two inputs and merges them into one output. If Input1 has M components, and Input2 has N components, the output will have M+\-N components with input1 components coming first.

To create an instance of class vtk\-Image\-Append\-Components, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageAppendComponents
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Append\-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\-Image\-Append\-Components class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Append\-Components = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Append\-Components = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Replace\-Nth\-Input\-Connection (int idx, vtk\-Algorithm\-Output input)} -\/ Replace one of the input connections with a new input. You can only replace input connections that you previously created with Add\-Input\-Connection() or, in the case of the first input, with Set\-Input\-Connection().  
\item {\ttfamily obj.\-Set\-Input (int num, vtk\-Data\-Object input)} -\/ Set an Input of this filter. This method is only for support of old-\/style pipeline connections. When writing new code you should use Set\-Input\-Connection(), Add\-Input\-Connection(), and Replace\-Nth\-Input\-Connection() instead.  
\item {\ttfamily obj.\-Set\-Input (vtk\-Data\-Object input)} -\/ Set an Input of this filter. This method is only for support of old-\/style pipeline connections. When writing new code you should use Set\-Input\-Connection(), Add\-Input\-Connection(), and Replace\-Nth\-Input\-Connection() instead.  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Input (int num)} -\/ Get one input to this filter. This method is only for support of old-\/style pipeline connections. When writing new code you should use vtk\-Algorithm\-::\-Get\-Input\-Connection(0, num).  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Input ()} -\/ Get one input to this filter. This method is only for support of old-\/style pipeline connections. When writing new code you should use vtk\-Algorithm\-::\-Get\-Input\-Connection(0, num).  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Inputs ()} -\/ Get the number of inputs to this filter. This method is only for support of old-\/style pipeline connections. When writing new code you should use vtk\-Algorithm\-::\-Get\-Number\-Of\-Input\-Connections(0).  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageblend}{}\section{vtk\-Image\-Blend}\label{vtkimaging_vtkimageblend}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Blend takes L, L\-A, R\-G\-B, or R\-G\-B\-A images as input and blends them according to the alpha values and/or the opacity setting for each input.

The spacing, origin, extent, and number of components of the output are the same as those for the first input. If the input has an alpha component, then this component is copied unchanged into the output. In addition, if the first input has either one component or two components i.\-e. if it is either L (greyscale) or L\-A (greyscale + alpha) then all other inputs must also be L or L\-A.

Different blending modes are available\-:

{\itshape Normal} (default) \-: This is the standard blending mode used by Open\-G\-L and other graphics packages. The output always has the same number of components and the same extent as the first input. The alpha value of the first input is not used in the blending computation, instead it is copied directly to the output.

\begin{DoxyVerb} output <- input[0]
 foreach input i {
   foreach pixel px {
     r <- input[i](px)(alpha) * opacity[i]
     f <- (255 - r)
     output(px) <- output(px) * f + input(px) * r
   }
 }\end{DoxyVerb}


{\itshape Compound} \-: Images are compounded together and each component is scaled by the sum of the alpha/opacity values. Use the Compound\-Threshold method to set specify a threshold in compound mode. Pixels with opacity$\ast$alpha less or equal than this threshold are ignored. The alpha value of the first input, if present, is N\-O\-T copied to the alpha value of the output. The output always has the same number of components and the same extent as the first input.

\begin{DoxyVerb} output <- 0
 foreach pixel px {
   sum <- 0
   foreach input i {
     r <- input[i](px)(alpha) * opacity(i)
     sum <- sum + r
     if r > threshold {
       output(px) <- output(px) + input(px) * r
     }
   }
   output(px) <- output(px) / sum
 }\end{DoxyVerb}


To create an instance of class vtk\-Image\-Blend, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageBlend
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Blend has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Blend class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Blend = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Blend = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Replace\-Nth\-Input\-Connection (int idx, vtk\-Algorithm\-Output input)} -\/ Replace one of the input connections with a new input. You can only replace input connections that you previously created with Add\-Input\-Connection() or, in the case of the first input, with Set\-Input\-Connection().  
\item {\ttfamily obj.\-Set\-Input (int num, vtk\-Data\-Object input)} -\/ Set an Input of this filter. This method is only for support of old-\/style pipeline connections. When writing new code you should use Set\-Input\-Connection(), Add\-Input\-Connection(), and Replace\-Nth\-Input\-Connection() instead.  
\item {\ttfamily obj.\-Set\-Input (vtk\-Data\-Object input)} -\/ Set an Input of this filter. This method is only for support of old-\/style pipeline connections. When writing new code you should use Set\-Input\-Connection(), Add\-Input\-Connection(), and Replace\-Nth\-Input\-Connection() instead.  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Input (int num)} -\/ Get one input to this filter. This method is only for support of old-\/style pipeline connections. When writing new code you should use vtk\-Algorithm\-::\-Get\-Input\-Connection(0, num).  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Input ()} -\/ Get one input to this filter. This method is only for support of old-\/style pipeline connections. When writing new code you should use vtk\-Algorithm\-::\-Get\-Input\-Connection(0, num).  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Inputs ()} -\/ Get the number of inputs to this filter. This method is only for support of old-\/style pipeline connections. When writing new code you should use vtk\-Algorithm\-::\-Get\-Number\-Of\-Input\-Connections(0).  
\item {\ttfamily obj.\-Set\-Opacity (int idx, double opacity)} -\/ Set the opacity of an input image\-: the alpha values of the image are multiplied by the opacity. The opacity of image idx=0 is ignored.  
\item {\ttfamily double = obj.\-Get\-Opacity (int idx)} -\/ Set the opacity of an input image\-: the alpha values of the image are multiplied by the opacity. The opacity of image idx=0 is ignored.  
\item {\ttfamily obj.\-Set\-Stencil (vtk\-Image\-Stencil\-Data stencil)} -\/ Set a stencil to apply when blending the data.  
\item {\ttfamily vtk\-Image\-Stencil\-Data = obj.\-Get\-Stencil ()} -\/ Set a stencil to apply when blending the data.  
\item {\ttfamily obj.\-Set\-Blend\-Mode (int )} -\/ Set the blend mode  
\item {\ttfamily int = obj.\-Get\-Blend\-Mode\-Min\-Value ()} -\/ Set the blend mode  
\item {\ttfamily int = obj.\-Get\-Blend\-Mode\-Max\-Value ()} -\/ Set the blend mode  
\item {\ttfamily int = obj.\-Get\-Blend\-Mode ()} -\/ Set the blend mode  
\item {\ttfamily obj.\-Set\-Blend\-Mode\-To\-Normal ()} -\/ Set the blend mode  
\item {\ttfamily obj.\-Set\-Blend\-Mode\-To\-Compound ()} -\/ Set the blend mode  
\item {\ttfamily string = obj.\-Get\-Blend\-Mode\-As\-String (void )} -\/ Set the blend mode  
\item {\ttfamily obj.\-Set\-Compound\-Threshold (double )} -\/ Specify a threshold in compound mode. Pixels with opacity$\ast$alpha less or equal the threshold are ignored.  
\item {\ttfamily double = obj.\-Get\-Compound\-Threshold ()} -\/ Specify a threshold in compound mode. Pixels with opacity$\ast$alpha less or equal the threshold are ignored.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagebutterworthhighpass}{}\section{vtk\-Image\-Butterworth\-High\-Pass}\label{vtkimaging_vtkimagebutterworthhighpass}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This filter only works on an image after it has been converted to frequency domain by a vtk\-Image\-F\-F\-T filter. A vtk\-Image\-R\-F\-F\-T filter can be used to convert the output back into the spatial domain. vtk\-Image\-Butterworth\-High\-Pass the frequency components around 0 are attenuated. Input and output are in doubles, with two components (complex numbers). out(i, j) = 1 / (1 + pow(Cut\-Off/\-Freq(i,j), 2$\ast$\-Order));

To create an instance of class vtk\-Image\-Butterworth\-High\-Pass, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageButterworthHighPass
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Butterworth\-High\-Pass has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Butterworth\-High\-Pass class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Butterworth\-High\-Pass = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Butterworth\-High\-Pass = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Cut\-Off (double , double , double )} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily obj.\-Set\-Cut\-Off (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily obj.\-Set\-Cut\-Off (double v)} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily obj.\-Set\-X\-Cut\-Off (double v)} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily obj.\-Set\-Y\-Cut\-Off (double v)} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily obj.\-Set\-Z\-Cut\-Off (double v)} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily double = obj. Get\-Cut\-Off ()} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily double = obj.\-Get\-X\-Cut\-Off ()} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily double = obj.\-Get\-Y\-Cut\-Off ()} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily double = obj.\-Get\-Z\-Cut\-Off ()} -\/ The order determines sharpness of the cutoff curve.  
\item {\ttfamily obj.\-Set\-Order (int )} -\/ The order determines sharpness of the cutoff curve.  
\item {\ttfamily int = obj.\-Get\-Order ()} -\/ The order determines sharpness of the cutoff curve.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagebutterworthlowpass}{}\section{vtk\-Image\-Butterworth\-Low\-Pass}\label{vtkimaging_vtkimagebutterworthlowpass}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This filter only works on an image after it has been converted to frequency domain by a vtk\-Image\-F\-F\-T filter. A vtk\-Image\-R\-F\-F\-T filter can be used to convert the output back into the spatial domain. vtk\-Image\-Butterworth\-Low\-Pass the high frequency components are attenuated. Input and output are in doubles, with two components (complex numbers). out(i, j) = (1 + pow(Cut\-Off/\-Freq(i,j), 2$\ast$\-Order));

To create an instance of class vtk\-Image\-Butterworth\-Low\-Pass, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageButterworthLowPass
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Butterworth\-Low\-Pass has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Butterworth\-Low\-Pass class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Butterworth\-Low\-Pass = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Butterworth\-Low\-Pass = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Cut\-Off (double , double , double )} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily obj.\-Set\-Cut\-Off (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily obj.\-Set\-Cut\-Off (double v)} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily obj.\-Set\-X\-Cut\-Off (double v)} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily obj.\-Set\-Y\-Cut\-Off (double v)} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily obj.\-Set\-Z\-Cut\-Off (double v)} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily double = obj. Get\-Cut\-Off ()} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily double = obj.\-Get\-X\-Cut\-Off ()} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily double = obj.\-Get\-Y\-Cut\-Off ()} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily double = obj.\-Get\-Z\-Cut\-Off ()} -\/ The order determines sharpness of the cutoff curve.  
\item {\ttfamily obj.\-Set\-Order (int )} -\/ The order determines sharpness of the cutoff curve.  
\item {\ttfamily int = obj.\-Get\-Order ()} -\/ The order determines sharpness of the cutoff curve.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagecachefilter}{}\section{vtk\-Image\-Cache\-Filter}\label{vtkimaging_vtkimagecachefilter}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Cache\-Filter keep a number of vtk\-Image\-Data\-Objects from previous updates to satisfy future updates without needing to update the input. It does not change the data at all. It just makes the pipeline more efficient at the expense of using extra memory.

To create an instance of class vtk\-Image\-Cache\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageCacheFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Cache\-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\-Cache\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Cache\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Cache\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Cache\-Size (int size)} -\/ This is the maximum number of images that can be retained in memory. it defaults to 10.  
\item {\ttfamily int = obj.\-Get\-Cache\-Size ()} -\/ This is the maximum number of images that can be retained in memory. it defaults to 10.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagecanvassource2d}{}\section{vtk\-Image\-Canvas\-Source2\-D}\label{vtkimaging_vtkimagecanvassource2d}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Canvas\-Source2\-D is a source that starts as a blank image. you may add to the image with two-\/dimensional drawing routines. It can paint multi-\/spectral images.

To create an instance of class vtk\-Image\-Canvas\-Source2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageCanvasSource2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Canvas\-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\-Image\-Canvas\-Source2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Canvas\-Source2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Canvas\-Source2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Draw\-Color (double , double , double , double )} -\/ Set/\-Get Draw\-Color. This is the value that is used when filling data or drawing lines. Default is (0,0,0,0)  
\item {\ttfamily obj.\-Set\-Draw\-Color (double a\mbox{[}4\mbox{]})} -\/ Set/\-Get Draw\-Color. This is the value that is used when filling data or drawing lines. Default is (0,0,0,0)  
\item {\ttfamily double = obj. Get\-Draw\-Color ()} -\/ Set/\-Get Draw\-Color. This is the value that is used when filling data or drawing lines. Default is (0,0,0,0)  
\item {\ttfamily obj.\-Set\-Draw\-Color (double a)} -\/ Set Draw\-Color to (a, b, 0, 0)  
\item {\ttfamily obj.\-Set\-Draw\-Color (double a, double b)} -\/ Set Draw\-Color to (a, b, c, 0)  
\item {\ttfamily obj.\-Set\-Draw\-Color (double a, double b, double c)} -\/ Set the pixels inside the box (min0, max0, min1, max1) to the current Draw\-Color  
\item {\ttfamily obj.\-Fill\-Box (int min0, int max0, int min1, int max1)} -\/ Set the pixels inside the box (min0, max0, min1, max1) to the current Draw\-Color  
\item {\ttfamily obj.\-Fill\-Tube (int x0, int y0, int x1, int y1, double radius)} -\/ Set the pixels inside the box (min0, max0, min1, max1) to the current Draw\-Color  
\item {\ttfamily obj.\-Fill\-Triangle (int x0, int y0, int x1, int y1, int x2, int y2)} -\/ Set the pixels inside the box (min0, max0, min1, max1) to the current Draw\-Color  
\item {\ttfamily obj.\-Draw\-Circle (int c0, int c1, double radius)} -\/ Set the pixels inside the box (min0, max0, min1, max1) to the current Draw\-Color  
\item {\ttfamily obj.\-Draw\-Point (int p0, int p1)} -\/ Set the pixels inside the box (min0, max0, min1, max1) to the current Draw\-Color  
\item {\ttfamily obj.\-Draw\-Segment (int x0, int y0, int x1, int y1)} -\/ Set the pixels inside the box (min0, max0, min1, max1) to the current Draw\-Color  
\item {\ttfamily obj.\-Draw\-Segment3\-D (double p0, double p1)} -\/ Set the pixels inside the box (min0, max0, min1, max1) to the current Draw\-Color  
\item {\ttfamily obj.\-Draw\-Segment3\-D (double x1, double y1, double z1, double x2, double y2, double z2)} -\/ Draw subimage of the input image in the canvas at position x0 and y0. The subimage is defined with sx, sy, width, and height.  
\item {\ttfamily obj.\-Draw\-Image (int x0, int y0, vtk\-Image\-Data i)} -\/ Draw subimage of the input image in the canvas at position x0 and y0. The subimage is defined with sx, sy, width, and height.  
\item {\ttfamily obj.\-Draw\-Image (int x0, int y0, vtk\-Image\-Data , int sx, int sy, int width, int height)} -\/ Draw subimage of the input image in the canvas at position x0 and y0. The subimage is defined with sx, sy, width, and height.  
\item {\ttfamily obj.\-Fill\-Pixel (int x, int y)} -\/ Fill a colored area with another color. (like connectivity) All pixels connected (and with the same value) to pixel (x, y) get replaced by the current \char`\"{}\-Draw\-Color\char`\"{}.  
\item {\ttfamily obj.\-Set\-Extent (int extent)} -\/ These methods set the Whole\-Extent of the output It sets the size of the canvas. Extent is a min max 3\-D box. Minimums and maximums are inclusive.  
\item {\ttfamily obj.\-Set\-Extent (int x1, int x2, int y1, int y2, int z1, int z2)} -\/ These methods set the Whole\-Extent of the output It sets the size of the canvas. Extent is a min max 3\-D box. Minimums and maximums are inclusive.  
\item {\ttfamily obj.\-Set\-Default\-Z (int )} -\/ The drawing operations can only draw into one 2\-D X\-Y plane at a time. If the canvas is a 3\-D volume, then this z value is used as the default for 2\-D operations. The default is 0.  
\item {\ttfamily int = obj.\-Get\-Default\-Z ()} -\/ The drawing operations can only draw into one 2\-D X\-Y plane at a time. If the canvas is a 3\-D volume, then this z value is used as the default for 2\-D operations. The default is 0.  
\item {\ttfamily obj.\-Set\-Ratio (double , double , double )} -\/ Set/\-Get Ratio. This is the value that is used to pre-\/multiply each (x, y, z) drawing coordinates (including Default\-Z). The default is (1, 1, 1)  
\item {\ttfamily obj.\-Set\-Ratio (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get Ratio. This is the value that is used to pre-\/multiply each (x, y, z) drawing coordinates (including Default\-Z). The default is (1, 1, 1)  
\item {\ttfamily double = obj. Get\-Ratio ()} -\/ Set/\-Get Ratio. This is the value that is used to pre-\/multiply each (x, y, z) drawing coordinates (including Default\-Z). The default is (1, 1, 1)  
\item {\ttfamily obj.\-Set\-Number\-Of\-Scalar\-Components (int i)} -\/ Set the number of scalar components  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Scalar\-Components () const} -\/ Set the number of scalar components  
\item {\ttfamily obj.\-Set\-Scalar\-Type\-To\-Float ()} -\/ Set/\-Get the data scalar type (i.\-e V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E). Note that these methods are setting and getting the pipeline scalar type. i.\-e. they are setting the type that the image data will be once it has executed. Until the R\-E\-Q\-U\-E\-S\-T\-\_\-\-D\-A\-T\-A pass the actual scalars may be of some other type. This is for backwards compatibility  
\item {\ttfamily obj.\-Set\-Scalar\-Type\-To\-Double ()} -\/ Set/\-Get the data scalar type (i.\-e V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E). Note that these methods are setting and getting the pipeline scalar type. i.\-e. they are setting the type that the image data will be once it has executed. Until the R\-E\-Q\-U\-E\-S\-T\-\_\-\-D\-A\-T\-A pass the actual scalars may be of some other type. This is for backwards compatibility  
\item {\ttfamily obj.\-Set\-Scalar\-Type\-To\-Int ()} -\/ Set/\-Get the data scalar type (i.\-e V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E). Note that these methods are setting and getting the pipeline scalar type. i.\-e. they are setting the type that the image data will be once it has executed. Until the R\-E\-Q\-U\-E\-S\-T\-\_\-\-D\-A\-T\-A pass the actual scalars may be of some other type. This is for backwards compatibility  
\item {\ttfamily obj.\-Set\-Scalar\-Type\-To\-Unsigned\-Int ()} -\/ Set/\-Get the data scalar type (i.\-e V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E). Note that these methods are setting and getting the pipeline scalar type. i.\-e. they are setting the type that the image data will be once it has executed. Until the R\-E\-Q\-U\-E\-S\-T\-\_\-\-D\-A\-T\-A pass the actual scalars may be of some other type. This is for backwards compatibility  
\item {\ttfamily obj.\-Set\-Scalar\-Type\-To\-Long ()} -\/ Set/\-Get the data scalar type (i.\-e V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E). Note that these methods are setting and getting the pipeline scalar type. i.\-e. they are setting the type that the image data will be once it has executed. Until the R\-E\-Q\-U\-E\-S\-T\-\_\-\-D\-A\-T\-A pass the actual scalars may be of some other type. This is for backwards compatibility  
\item {\ttfamily obj.\-Set\-Scalar\-Type\-To\-Unsigned\-Long ()} -\/ Set/\-Get the data scalar type (i.\-e V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E). Note that these methods are setting and getting the pipeline scalar type. i.\-e. they are setting the type that the image data will be once it has executed. Until the R\-E\-Q\-U\-E\-S\-T\-\_\-\-D\-A\-T\-A pass the actual scalars may be of some other type. This is for backwards compatibility  
\item {\ttfamily obj.\-Set\-Scalar\-Type\-To\-Short ()} -\/ Set/\-Get the data scalar type (i.\-e V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E). Note that these methods are setting and getting the pipeline scalar type. i.\-e. they are setting the type that the image data will be once it has executed. Until the R\-E\-Q\-U\-E\-S\-T\-\_\-\-D\-A\-T\-A pass the actual scalars may be of some other type. This is for backwards compatibility  
\item {\ttfamily obj.\-Set\-Scalar\-Type\-To\-Unsigned\-Short ()} -\/ Set/\-Get the data scalar type (i.\-e V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E). Note that these methods are setting and getting the pipeline scalar type. i.\-e. they are setting the type that the image data will be once it has executed. Until the R\-E\-Q\-U\-E\-S\-T\-\_\-\-D\-A\-T\-A pass the actual scalars may be of some other type. This is for backwards compatibility  
\item {\ttfamily obj.\-Set\-Scalar\-Type\-To\-Unsigned\-Char ()} -\/ Set/\-Get the data scalar type (i.\-e V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E). Note that these methods are setting and getting the pipeline scalar type. i.\-e. they are setting the type that the image data will be once it has executed. Until the R\-E\-Q\-U\-E\-S\-T\-\_\-\-D\-A\-T\-A pass the actual scalars may be of some other type. This is for backwards compatibility  
\item {\ttfamily obj.\-Set\-Scalar\-Type\-To\-Char ()} -\/ Set/\-Get the data scalar type (i.\-e V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E). Note that these methods are setting and getting the pipeline scalar type. i.\-e. they are setting the type that the image data will be once it has executed. Until the R\-E\-Q\-U\-E\-S\-T\-\_\-\-D\-A\-T\-A pass the actual scalars may be of some other type. This is for backwards compatibility  
\item {\ttfamily obj.\-Set\-Scalar\-Type (int )} -\/ Set/\-Get the data scalar type (i.\-e V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E). Note that these methods are setting and getting the pipeline scalar type. i.\-e. they are setting the type that the image data will be once it has executed. Until the R\-E\-Q\-U\-E\-S\-T\-\_\-\-D\-A\-T\-A pass the actual scalars may be of some other type. This is for backwards compatibility  
\item {\ttfamily int = obj.\-Get\-Scalar\-Type () const} -\/ Set/\-Get the data scalar type (i.\-e V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E). Note that these methods are setting and getting the pipeline scalar type. i.\-e. they are setting the type that the image data will be once it has executed. Until the R\-E\-Q\-U\-E\-S\-T\-\_\-\-D\-A\-T\-A pass the actual scalars may be of some other type. This is for backwards compatibility  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagecast}{}\section{vtk\-Image\-Cast}\label{vtkimaging_vtkimagecast}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Cast filter casts the input type to match the output type in the image processing pipeline. The filter does nothing if the input already has the correct type. To specify the \char`\"{}\-Cast\-To\char`\"{} type, use \char`\"{}\-Set\-Output\-Scalar\-Type\char`\"{} method.

To create an instance of class vtk\-Image\-Cast, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageCast
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Cast has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Cast class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Cast = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Cast = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type (int )} -\/ Set the desired output scalar type to cast to.  
\item {\ttfamily int = obj.\-Get\-Output\-Scalar\-Type ()} -\/ Set the desired output scalar type to cast to.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Float ()} -\/ Set the desired output scalar type to cast to.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Double ()} -\/ Set the desired output scalar type to cast to.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Int ()} -\/ Set the desired output scalar type to cast to.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Unsigned\-Int ()} -\/ Set the desired output scalar type to cast to.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Long ()} -\/ Set the desired output scalar type to cast to.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Unsigned\-Long ()} -\/ Set the desired output scalar type to cast to.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Short ()} -\/ Set the desired output scalar type to cast to.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Unsigned\-Short ()} -\/ Set the desired output scalar type to cast to.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Unsigned\-Char ()} -\/ Set the desired output scalar type to cast to.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Char ()} -\/ Set the desired output scalar type to cast to.  
\item {\ttfamily obj.\-Set\-Clamp\-Overflow (int )} -\/ When the Clamp\-Overflow flag is on, the data is thresholded so that the output value does not exceed the max or min of the data type. By default Clamp\-Overflow is off.  
\item {\ttfamily int = obj.\-Get\-Clamp\-Overflow ()} -\/ When the Clamp\-Overflow flag is on, the data is thresholded so that the output value does not exceed the max or min of the data type. By default Clamp\-Overflow is off.  
\item {\ttfamily obj.\-Clamp\-Overflow\-On ()} -\/ When the Clamp\-Overflow flag is on, the data is thresholded so that the output value does not exceed the max or min of the data type. By default Clamp\-Overflow is off.  
\item {\ttfamily obj.\-Clamp\-Overflow\-Off ()} -\/ When the Clamp\-Overflow flag is on, the data is thresholded so that the output value does not exceed the max or min of the data type. By default Clamp\-Overflow is off.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagechangeinformation}{}\section{vtk\-Image\-Change\-Information}\label{vtkimaging_vtkimagechangeinformation}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Change\-Information modify the spacing, origin, or extent of the data without changing the data itself. The data is not resampled by this filter, only the information accompanying the data is modified.

To create an instance of class vtk\-Image\-Change\-Information, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageChangeInformation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Change\-Information has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Image\-Change\-Information class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Change\-Information = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Change\-Information = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Information\-Input (vtk\-Image\-Data )} -\/ Copy the information from another data set. By default, the information is copied from the input.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Information\-Input ()} -\/ Copy the information from another data set. By default, the information is copied from the input.  
\item {\ttfamily obj.\-Set\-Output\-Extent\-Start (int , int , int )} -\/ Specify new starting values for the extent explicitly. These values are used as Whole\-Extent\mbox{[}0\mbox{]}, Whole\-Extent\mbox{[}2\mbox{]} and Whole\-Extent\mbox{[}4\mbox{]} of the output. The default is to the use the extent start of the Input, or of the Information\-Input if Information\-Input is set.  
\item {\ttfamily obj.\-Set\-Output\-Extent\-Start (int a\mbox{[}3\mbox{]})} -\/ Specify new starting values for the extent explicitly. These values are used as Whole\-Extent\mbox{[}0\mbox{]}, Whole\-Extent\mbox{[}2\mbox{]} and Whole\-Extent\mbox{[}4\mbox{]} of the output. The default is to the use the extent start of the Input, or of the Information\-Input if Information\-Input is set.  
\item {\ttfamily int = obj. Get\-Output\-Extent\-Start ()} -\/ Specify new starting values for the extent explicitly. These values are used as Whole\-Extent\mbox{[}0\mbox{]}, Whole\-Extent\mbox{[}2\mbox{]} and Whole\-Extent\mbox{[}4\mbox{]} of the output. The default is to the use the extent start of the Input, or of the Information\-Input if Information\-Input is set.  
\item {\ttfamily obj.\-Set\-Output\-Spacing (double , double , double )} -\/ Specify a new data spacing explicitly. The default is to use the spacing of the Input, or of the Information\-Input if Information\-Input is set.  
\item {\ttfamily obj.\-Set\-Output\-Spacing (double a\mbox{[}3\mbox{]})} -\/ Specify a new data spacing explicitly. The default is to use the spacing of the Input, or of the Information\-Input if Information\-Input is set.  
\item {\ttfamily double = obj. Get\-Output\-Spacing ()} -\/ Specify a new data spacing explicitly. The default is to use the spacing of the Input, or of the Information\-Input if Information\-Input is set.  
\item {\ttfamily obj.\-Set\-Output\-Origin (double , double , double )} -\/ Specify a new data origin explicitly. The default is to use the origin of the Input, or of the Information\-Input if Information\-Input is set.  
\item {\ttfamily obj.\-Set\-Output\-Origin (double a\mbox{[}3\mbox{]})} -\/ Specify a new data origin explicitly. The default is to use the origin of the Input, or of the Information\-Input if Information\-Input is set.  
\item {\ttfamily double = obj. Get\-Output\-Origin ()} -\/ Specify a new data origin explicitly. The default is to use the origin of the Input, or of the Information\-Input if Information\-Input is set.  
\item {\ttfamily obj.\-Set\-Center\-Image (int )} -\/ Set the Origin of the output so that image coordinate (0,0,0) lies at the Center of the data set. This will override Set\-Output\-Origin. This is often a useful operation to apply before using vtk\-Image\-Reslice to apply a transformation to an image.  
\item {\ttfamily obj.\-Center\-Image\-On ()} -\/ Set the Origin of the output so that image coordinate (0,0,0) lies at the Center of the data set. This will override Set\-Output\-Origin. This is often a useful operation to apply before using vtk\-Image\-Reslice to apply a transformation to an image.  
\item {\ttfamily obj.\-Center\-Image\-Off ()} -\/ Set the Origin of the output so that image coordinate (0,0,0) lies at the Center of the data set. This will override Set\-Output\-Origin. This is often a useful operation to apply before using vtk\-Image\-Reslice to apply a transformation to an image.  
\item {\ttfamily int = obj.\-Get\-Center\-Image ()} -\/ Set the Origin of the output so that image coordinate (0,0,0) lies at the Center of the data set. This will override Set\-Output\-Origin. This is often a useful operation to apply before using vtk\-Image\-Reslice to apply a transformation to an image.  
\item {\ttfamily obj.\-Set\-Extent\-Translation (int , int , int )} -\/ Apply a translation to the extent.  
\item {\ttfamily obj.\-Set\-Extent\-Translation (int a\mbox{[}3\mbox{]})} -\/ Apply a translation to the extent.  
\item {\ttfamily int = obj. Get\-Extent\-Translation ()} -\/ Apply a translation to the extent.  
\item {\ttfamily obj.\-Set\-Spacing\-Scale (double , double , double )} -\/ Apply a scale factor to the spacing.  
\item {\ttfamily obj.\-Set\-Spacing\-Scale (double a\mbox{[}3\mbox{]})} -\/ Apply a scale factor to the spacing.  
\item {\ttfamily double = obj. Get\-Spacing\-Scale ()} -\/ Apply a scale factor to the spacing.  
\item {\ttfamily obj.\-Set\-Origin\-Translation (double , double , double )} -\/ Apply a translation to the origin.  
\item {\ttfamily obj.\-Set\-Origin\-Translation (double a\mbox{[}3\mbox{]})} -\/ Apply a translation to the origin.  
\item {\ttfamily double = obj. Get\-Origin\-Translation ()} -\/ Apply a translation to the origin.  
\item {\ttfamily obj.\-Set\-Origin\-Scale (double , double , double )} -\/ Apply a scale to the origin. The scale is applied before the translation.  
\item {\ttfamily obj.\-Set\-Origin\-Scale (double a\mbox{[}3\mbox{]})} -\/ Apply a scale to the origin. The scale is applied before the translation.  
\item {\ttfamily double = obj. Get\-Origin\-Scale ()} -\/ Apply a scale to the origin. The scale is applied before the translation.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagecheckerboard}{}\section{vtk\-Image\-Checkerboard}\label{vtkimaging_vtkimagecheckerboard}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Checkerboard displays two images as one using a checkerboard pattern. This filter can be used to compare two images. The checkerboard pattern is controlled by the Number\-Of\-Divisions ivar. This controls the number of checkerboard divisions in the whole extent of the image.

To create an instance of class vtk\-Image\-Checkerboard, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageCheckerboard
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Checkerboard has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Checkerboard class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Checkerboard = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Checkerboard = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Number\-Of\-Divisions (int , int , int )} -\/ Set/\-Get the number of divisions along each axis.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Divisions (int a\mbox{[}3\mbox{]})} -\/ Set/\-Get the number of divisions along each axis.  
\item {\ttfamily int = obj. Get\-Number\-Of\-Divisions ()} -\/ Set/\-Get the number of divisions along each axis.  
\item {\ttfamily obj.\-Set\-Input1 (vtk\-Data\-Object in)} -\/ Set the two inputs to this filter  
\item {\ttfamily obj.\-Set\-Input2 (vtk\-Data\-Object in)}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagecityblockdistance}{}\section{vtk\-Image\-City\-Block\-Distance}\label{vtkimaging_vtkimagecityblockdistance}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-City\-Block\-Distance creates a distance map using the city block (Manhatten) distance measure. The input is a mask. Zero values are considered boundaries. The output pixel is the minimum of the input pixel and the distance to a boundary (or neighbor value + 1 unit). distance values are calculated in pixels. The filter works by taking 6 passes (for 3d distance map)\-: 2 along each axis (forward and backward). Each pass keeps a running minimum distance. For some reason, I preserve the sign if the distance. If the input mask is initially negative, the output distances will be negative. Distances maps can have inside (negative regions) and outsides (positive regions).

To create an instance of class vtk\-Image\-City\-Block\-Distance, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageCityBlockDistance
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-City\-Block\-Distance has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-City\-Block\-Distance class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-City\-Block\-Distance = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-City\-Block\-Distance = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageclip}{}\section{vtk\-Image\-Clip}\label{vtkimaging_vtkimageclip}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-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\-Image\-Clip, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageClip
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-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\-Image\-Clip class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Clip = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-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 int = obj.\-Get\-Output\-Whole\-Extent ()}  
\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{vtkimaging_vtkimageconnector}{}\section{vtk\-Image\-Connector}\label{vtkimaging_vtkimageconnector}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Connector is a helper class for connectivity filters. It is not meant to be used directly. It implements a stack and breadth first search necessary for some connectivity filters. Filtered axes sets the dimensionality of the neighbor comparison, and cannot be more than three dimensions. As implemented, only voxels which share faces are considered neighbors.

To create an instance of class vtk\-Image\-Connector, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageConnector
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Connector has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Connector class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Connector = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Connector = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Remove\-All\-Seeds ()}  
\item {\ttfamily obj.\-Set\-Connected\-Value (char )} -\/ Values used by the Mark\-Region method  
\item {\ttfamily char = obj.\-Get\-Connected\-Value ()} -\/ Values used by the Mark\-Region method  
\item {\ttfamily obj.\-Set\-Unconnected\-Value (char )} -\/ Values used by the Mark\-Region method  
\item {\ttfamily char = obj.\-Get\-Unconnected\-Value ()} -\/ Values used by the Mark\-Region method  
\item {\ttfamily obj.\-Mark\-Data (vtk\-Image\-Data data, int dimensionality, int ext\mbox{[}6\mbox{]})} -\/ Input a data of 0's and \char`\"{}\-Unconnected\-Value\char`\"{}s. Seeds of this object are used to find connected pixels. All pixels connected to seeds are set to Connected\-Value. The data has to be unsigned char.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageconstantpad}{}\section{vtk\-Image\-Constant\-Pad}\label{vtkimaging_vtkimageconstantpad}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Constant\-Pad changes the image extent of its input. Any pixels outside of the original image extent are filled with a constant value (default is 0.\-0).

To create an instance of class vtk\-Image\-Constant\-Pad, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageConstantPad
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Constant\-Pad has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Constant\-Pad class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Constant\-Pad = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Constant\-Pad = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Constant (double )} -\/ Set/\-Get the pad value.  
\item {\ttfamily double = obj.\-Get\-Constant ()} -\/ Set/\-Get the pad value.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagecontinuousdilate3d}{}\section{vtk\-Image\-Continuous\-Dilate3\-D}\label{vtkimaging_vtkimagecontinuousdilate3d}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Continuous\-Dilate3\-D replaces a pixel with the maximum over an ellipsoidal neighborhood. If Kernel\-Size of an axis is 1, no processing is done on that axis.

To create an instance of class vtk\-Image\-Continuous\-Dilate3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageContinuousDilate3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Continuous\-Dilate3\-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\-Image\-Continuous\-Dilate3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Construct an instance of vtk\-Image\-Continuous\-Dilate3\-D filter. By default zero values are dilated.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Construct an instance of vtk\-Image\-Continuous\-Dilate3\-D filter. By default zero values are dilated.  
\item {\ttfamily vtk\-Image\-Continuous\-Dilate3\-D = obj.\-New\-Instance ()} -\/ Construct an instance of vtk\-Image\-Continuous\-Dilate3\-D filter. By default zero values are dilated.  
\item {\ttfamily vtk\-Image\-Continuous\-Dilate3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Construct an instance of vtk\-Image\-Continuous\-Dilate3\-D filter. By default zero values are dilated.  
\item {\ttfamily obj.\-Set\-Kernel\-Size (int size0, int size1, int size2)} -\/ This method sets the size of the neighborhood. It also sets the default middle of the neighborhood and computes the elliptical foot print.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagecontinuouserode3d}{}\section{vtk\-Image\-Continuous\-Erode3\-D}\label{vtkimaging_vtkimagecontinuouserode3d}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Continuous\-Erode3\-D replaces a pixel with the minimum over an ellipsoidal neighborhood. If Kernel\-Size of an axis is 1, no processing is done on that axis.

To create an instance of class vtk\-Image\-Continuous\-Erode3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageContinuousErode3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Continuous\-Erode3\-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\-Image\-Continuous\-Erode3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Construct an instance of vtk\-Image\-Continuous\-Erode3\-D filter. By default zero values are eroded.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Construct an instance of vtk\-Image\-Continuous\-Erode3\-D filter. By default zero values are eroded.  
\item {\ttfamily vtk\-Image\-Continuous\-Erode3\-D = obj.\-New\-Instance ()} -\/ Construct an instance of vtk\-Image\-Continuous\-Erode3\-D filter. By default zero values are eroded.  
\item {\ttfamily vtk\-Image\-Continuous\-Erode3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Construct an instance of vtk\-Image\-Continuous\-Erode3\-D filter. By default zero values are eroded.  
\item {\ttfamily obj.\-Set\-Kernel\-Size (int size0, int size1, int size2)} -\/ This method sets the size of the neighborhood. It also sets the default middle of the neighborhood and computes the elliptical foot print.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageconvolve}{}\section{vtk\-Image\-Convolve}\label{vtkimaging_vtkimageconvolve}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Convolve convolves the image with a 3\-D Nx\-Nx\-N kernel or a 2\-D Nx\-N kernal. The output image is cropped to the same size as the input.

To create an instance of class vtk\-Image\-Convolve, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageConvolve
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Convolve has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Convolve class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Construct an instance of vtk\-Image\-Convolve filter.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Construct an instance of vtk\-Image\-Convolve filter.  
\item {\ttfamily vtk\-Image\-Convolve = obj.\-New\-Instance ()} -\/ Construct an instance of vtk\-Image\-Convolve filter.  
\item {\ttfamily vtk\-Image\-Convolve = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Construct an instance of vtk\-Image\-Convolve filter.  
\item {\ttfamily int = obj. Get\-Kernel\-Size ()} -\/ Get the kernel size  
\item {\ttfamily obj.\-Set\-Kernel3x3 (double kernel\mbox{[}9\mbox{]})} -\/ Set the kernel to be a given 3x3 or 5x5 or 7x7 kernel.  
\item {\ttfamily obj.\-Set\-Kernel5x5 (double kernel\mbox{[}25\mbox{]})} -\/ Set the kernel to be a given 3x3 or 5x5 or 7x7 kernel.  
\item {\ttfamily obj.\-Get\-Kernel3x3 (double kernel\mbox{[}9\mbox{]})} -\/ Return an array that contains the kernel.  
\item {\ttfamily obj.\-Get\-Kernel5x5 (double kernel\mbox{[}25\mbox{]})} -\/ Return an array that contains the kernel.  
\item {\ttfamily obj.\-Set\-Kernel3x3x3 (double kernel\mbox{[}27\mbox{]})} -\/ Set the kernel to be a 3x3x3 or 5x5x5 or 7x7x7 kernel.  
\item {\ttfamily obj.\-Get\-Kernel3x3x3 (double kernel\mbox{[}27\mbox{]})} -\/ Return an array that contains the kernel  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagecorrelation}{}\section{vtk\-Image\-Correlation}\label{vtkimaging_vtkimagecorrelation}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Correlation finds the correlation between two data sets. Set\-Dimensionality determines whether the Correlation will be 3\-D, 2\-D or 1\-D. The default is a 2\-D Correlation. The Output type will be double. The output size will match the size of the first input. The second input is considered the correlation kernel.

To create an instance of class vtk\-Image\-Correlation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageCorrelation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Correlation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Correlation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Correlation = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Correlation = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Dimensionality (int )} -\/ Determines how the input is interpreted (set of 2d slices ...). The default is 2.  
\item {\ttfamily int = obj.\-Get\-Dimensionality\-Min\-Value ()} -\/ Determines how the input is interpreted (set of 2d slices ...). The default is 2.  
\item {\ttfamily int = obj.\-Get\-Dimensionality\-Max\-Value ()} -\/ Determines how the input is interpreted (set of 2d slices ...). The default is 2.  
\item {\ttfamily int = obj.\-Get\-Dimensionality ()} -\/ Determines how the input is interpreted (set of 2d slices ...). The default is 2.  
\item {\ttfamily obj.\-Set\-Input1 (vtk\-Data\-Object in)} -\/ Set the correlation kernel.  
\item {\ttfamily obj.\-Set\-Input2 (vtk\-Data\-Object in)}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagecursor3d}{}\section{vtk\-Image\-Cursor3\-D}\label{vtkimaging_vtkimagecursor3d}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Cursor3\-D will draw a cursor on a 2d image or 3d volume.

To create an instance of class vtk\-Image\-Cursor3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageCursor3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-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\-Image\-Cursor3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Cursor3\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Cursor3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Cursor\-Position (double , double , double )} -\/ Sets/\-Gets the center point of the 3d cursor.  
\item {\ttfamily obj.\-Set\-Cursor\-Position (double a\mbox{[}3\mbox{]})} -\/ Sets/\-Gets the center point of the 3d cursor.  
\item {\ttfamily double = obj. Get\-Cursor\-Position ()} -\/ Sets/\-Gets the center point of the 3d cursor.  
\item {\ttfamily obj.\-Set\-Cursor\-Value (double )} -\/ Sets/\-Gets what pixel value to draw the cursor in.  
\item {\ttfamily double = obj.\-Get\-Cursor\-Value ()} -\/ Sets/\-Gets what pixel value to draw the cursor in.  
\item {\ttfamily obj.\-Set\-Cursor\-Radius (int )} -\/ Sets/\-Gets the radius of the cursor. The radius determines how far the axis lines project out from the cursors center.  
\item {\ttfamily int = obj.\-Get\-Cursor\-Radius ()} -\/ Sets/\-Gets the radius of the cursor. The radius determines how far the axis lines project out from the cursors center.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagedatastreamer}{}\section{vtk\-Image\-Data\-Streamer}\label{vtkimaging_vtkimagedatastreamer}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
To satisfy a request, this filter calls update on its input many times with smaller update extents. All processing up stream streams smaller pieces.

To create an instance of class vtk\-Image\-Data\-Streamer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageDataStreamer
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-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\-Image\-Data\-Streamer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Data\-Streamer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Data\-Streamer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Number\-Of\-Stream\-Divisions (int )} -\/ Set how many pieces to divide the input into. void Set\-Number\-Of\-Stream\-Divisions(int num); int Get\-Number\-Of\-Stream\-Divisions();  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Stream\-Divisions ()} -\/ Set how many pieces to divide the input into. void Set\-Number\-Of\-Stream\-Divisions(int num); int Get\-Number\-Of\-Stream\-Divisions();  
\item {\ttfamily obj.\-Update ()}  
\item {\ttfamily obj.\-Update\-Whole\-Extent ()}  
\item {\ttfamily obj.\-Set\-Extent\-Translator (vtk\-Extent\-Translator )} -\/ Get the extent translator that will be used to split the requests  
\item {\ttfamily vtk\-Extent\-Translator = obj.\-Get\-Extent\-Translator ()} -\/ Get the extent translator that will be used to split the requests  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagedecomposefilter}{}\section{vtk\-Image\-Decompose\-Filter}\label{vtkimaging_vtkimagedecomposefilter}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This superclass molds the vtk\-Image\-Iterate\-Filter superclass so it iterates over the axes. The filter uses dimensionality to determine how many axes to execute (starting from x). The filter also provides convenience methods for permuting information retrieved from input, output and vtk\-Image\-Data.

To create an instance of class vtk\-Image\-Decompose\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageDecomposeFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Decompose\-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\-Decompose\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Construct an instance of vtk\-Image\-Decompose\-Filter filter with default dimensionality 3.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Construct an instance of vtk\-Image\-Decompose\-Filter filter with default dimensionality 3.  
\item {\ttfamily vtk\-Image\-Decompose\-Filter = obj.\-New\-Instance ()} -\/ Construct an instance of vtk\-Image\-Decompose\-Filter filter with default dimensionality 3.  
\item {\ttfamily vtk\-Image\-Decompose\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Construct an instance of vtk\-Image\-Decompose\-Filter filter with default dimensionality 3.  
\item {\ttfamily obj.\-Set\-Dimensionality (int dim)} -\/ Dimensionality is the number of axes which are considered during execution. To process images dimensionality would be set to 2.  
\item {\ttfamily int = obj.\-Get\-Dimensionality ()} -\/ Dimensionality is the number of axes which are considered during execution. To process images dimensionality would be set to 2.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagedifference}{}\section{vtk\-Image\-Difference}\label{vtkimaging_vtkimagedifference}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Difference takes two rgb unsigned char images and compares them. It allows the images to be slightly different. If Allow\-Shift is on, then each pixel can be shifted by one pixel. Threshold is the allowable error for each pixel.

This is not a symetric filter and the difference computed is not symetric when Allow\-Shift is on. Specifically in that case a pixel in Set\-Image input will be compared to the matching pixel in the input as well as to the input's eight connected neighbors. B\-U\-T... the opposite is not true. So for example if a valid image (Set\-Image) has a single white pixel in it, it will not find a match in the input image if the input image is black (because none of the nine suspect pixels are white). In contrast, if there is a single white pixel in the input image and the valid image (Set\-Image) is all black it will match with no error because all it has to do is find black pixels and even though the input image has a white pixel, its neighbors are not white.

To create an instance of class vtk\-Image\-Difference, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageDifference
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Difference has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Difference class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Difference = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Difference = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Image (vtk\-Data\-Object image)} -\/ Specify the Image to compare the input to.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Image ()} -\/ Specify the Image to compare the input to.  
\item {\ttfamily double = obj.\-Get\-Error (void )} -\/ Return the total error in comparing the two images.  
\item {\ttfamily obj.\-Get\-Error (double e)} -\/ Return the total error in comparing the two images.  
\item {\ttfamily double = obj.\-Get\-Thresholded\-Error (void )} -\/ Return the total thresholded error in comparing the two images. The thresholded error is the error for a given pixel minus the threshold and clamped at a minimum of zero.  
\item {\ttfamily obj.\-Get\-Thresholded\-Error (double e)} -\/ Return the total thresholded error in comparing the two images. The thresholded error is the error for a given pixel minus the threshold and clamped at a minimum of zero.  
\item {\ttfamily obj.\-Set\-Threshold (int )} -\/ Specify a threshold tolerance for pixel differences.  
\item {\ttfamily int = obj.\-Get\-Threshold ()} -\/ Specify a threshold tolerance for pixel differences.  
\item {\ttfamily obj.\-Set\-Allow\-Shift (int )} -\/ Specify whether the comparison will allow a shift of one pixel between the images. If set, then the minimum difference between input images will be used to determine the difference. Otherwise, the difference is computed directly between pixels of identical row/column values.  
\item {\ttfamily int = obj.\-Get\-Allow\-Shift ()} -\/ Specify whether the comparison will allow a shift of one pixel between the images. If set, then the minimum difference between input images will be used to determine the difference. Otherwise, the difference is computed directly between pixels of identical row/column values.  
\item {\ttfamily obj.\-Allow\-Shift\-On ()} -\/ Specify whether the comparison will allow a shift of one pixel between the images. If set, then the minimum difference between input images will be used to determine the difference. Otherwise, the difference is computed directly between pixels of identical row/column values.  
\item {\ttfamily obj.\-Allow\-Shift\-Off ()} -\/ Specify whether the comparison will allow a shift of one pixel between the images. If set, then the minimum difference between input images will be used to determine the difference. Otherwise, the difference is computed directly between pixels of identical row/column values.  
\item {\ttfamily obj.\-Set\-Averaging (int )} -\/ Specify whether the comparison will include comparison of averaged 3x3 data between the images. For graphics renderings you normally would leave this on. For imaging operations it should be off.  
\item {\ttfamily int = obj.\-Get\-Averaging ()} -\/ Specify whether the comparison will include comparison of averaged 3x3 data between the images. For graphics renderings you normally would leave this on. For imaging operations it should be off.  
\item {\ttfamily obj.\-Averaging\-On ()} -\/ Specify whether the comparison will include comparison of averaged 3x3 data between the images. For graphics renderings you normally would leave this on. For imaging operations it should be off.  
\item {\ttfamily obj.\-Averaging\-Off ()} -\/ Specify whether the comparison will include comparison of averaged 3x3 data between the images. For graphics renderings you normally would leave this on. For imaging operations it should be off.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagedilateerode3d}{}\section{vtk\-Image\-Dilate\-Erode3\-D}\label{vtkimaging_vtkimagedilateerode3d}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Dilate\-Erode3\-D will dilate one value and erode another. It uses an elliptical foot print, and only erodes/dilates on the boundary of the two values. The filter is restricted to the X, Y, and Z axes for now. It can degenerate to a 2 or 1 dimensional filter by setting the kernel size to 1 for a specific axis.

To create an instance of class vtk\-Image\-Dilate\-Erode3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageDilateErode3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Dilate\-Erode3\-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\-Image\-Dilate\-Erode3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Construct an instance of vtk\-Image\-Dilate\-Erode3\-D filter. By default zero values are dilated.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Construct an instance of vtk\-Image\-Dilate\-Erode3\-D filter. By default zero values are dilated.  
\item {\ttfamily vtk\-Image\-Dilate\-Erode3\-D = obj.\-New\-Instance ()} -\/ Construct an instance of vtk\-Image\-Dilate\-Erode3\-D filter. By default zero values are dilated.  
\item {\ttfamily vtk\-Image\-Dilate\-Erode3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Construct an instance of vtk\-Image\-Dilate\-Erode3\-D filter. By default zero values are dilated.  
\item {\ttfamily obj.\-Set\-Kernel\-Size (int size0, int size1, int size2)} -\/ This method sets the size of the neighborhood. It also sets the default middle of the neighborhood and computes the elliptical foot print.  
\item {\ttfamily obj.\-Set\-Dilate\-Value (double )} -\/ Set/\-Get the Dilate and Erode values to be used by this filter.  
\item {\ttfamily double = obj.\-Get\-Dilate\-Value ()} -\/ Set/\-Get the Dilate and Erode values to be used by this filter.  
\item {\ttfamily obj.\-Set\-Erode\-Value (double )} -\/ Set/\-Get the Dilate and Erode values to be used by this filter.  
\item {\ttfamily double = obj.\-Get\-Erode\-Value ()} -\/ Set/\-Get the Dilate and Erode values to be used by this filter.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagedivergence}{}\section{vtk\-Image\-Divergence}\label{vtkimaging_vtkimagedivergence}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Divergence takes a 3\-D vector field and creates a scalar field which which represents the rate of change of the vector field. The definition of Divergence\-: Given V = P(x,y,z), Q(x,y,z), R(x,y,z), Divergence = d\-P/dx + d\-Q/dy + d\-R/dz.

To create an instance of class vtk\-Image\-Divergence, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageDivergence
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Divergence has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Divergence class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Divergence = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Divergence = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagedotproduct}{}\section{vtk\-Image\-Dot\-Product}\label{vtkimaging_vtkimagedotproduct}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Dot\-Product interprets the scalar components of two images as vectors and takes the dot product vector by vector (pixel by pixel).

To create an instance of class vtk\-Image\-Dot\-Product, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageDotProduct
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Dot\-Product has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Dot\-Product class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Dot\-Product = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Dot\-Product = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Input1 (vtk\-Data\-Object in)} -\/ Set the two inputs to this filter  
\item {\ttfamily obj.\-Set\-Input2 (vtk\-Data\-Object in)}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageellipsoidsource}{}\section{vtk\-Image\-Ellipsoid\-Source}\label{vtkimaging_vtkimageellipsoidsource}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Ellipsoid\-Source creates a binary image of a ellipsoid. It was created as an example of a simple source, and to test the mask filter. It is also used internally in vtk\-Image\-Dilate\-Erode3\-D.

To create an instance of class vtk\-Image\-Ellipsoid\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageEllipsoidSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Ellipsoid\-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\-Image\-Ellipsoid\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Ellipsoid\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Ellipsoid\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Whole\-Extent (int extent\mbox{[}6\mbox{]})} -\/ Set/\-Get the extent of the whole output image.  
\item {\ttfamily obj.\-Set\-Whole\-Extent (int min\-X, int max\-X, int min\-Y, int max\-Y, int min\-Z, int max\-Z)} -\/ Set/\-Get the extent of the whole output image.  
\item {\ttfamily obj.\-Get\-Whole\-Extent (int extent\mbox{[}6\mbox{]})} -\/ Set/\-Get the extent of the whole output image.  
\item {\ttfamily int = obj.\-Get\-Whole\-Extent ()} -\/ Set/\-Get the center of the ellipsoid.  
\item {\ttfamily obj.\-Set\-Center (double , double , double )} -\/ Set/\-Get the center of the ellipsoid.  
\item {\ttfamily obj.\-Set\-Center (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the center of the ellipsoid.  
\item {\ttfamily double = obj. Get\-Center ()} -\/ Set/\-Get the center of the ellipsoid.  
\item {\ttfamily obj.\-Set\-Radius (double , double , double )} -\/ Set/\-Get the radius of the ellipsoid.  
\item {\ttfamily obj.\-Set\-Radius (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the radius of the ellipsoid.  
\item {\ttfamily double = obj. Get\-Radius ()} -\/ Set/\-Get the radius of the ellipsoid.  
\item {\ttfamily obj.\-Set\-In\-Value (double )} -\/ Set/\-Get the inside pixel values.  
\item {\ttfamily double = obj.\-Get\-In\-Value ()} -\/ Set/\-Get the inside pixel values.  
\item {\ttfamily obj.\-Set\-Out\-Value (double )} -\/ Set/\-Get the outside pixel values.  
\item {\ttfamily double = obj.\-Get\-Out\-Value ()} -\/ Set/\-Get the outside pixel values.  
\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\-Float ()} -\/ 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\-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 ()}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageeuclideandistance}{}\section{vtk\-Image\-Euclidean\-Distance}\label{vtkimaging_vtkimageeuclideandistance}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Euclidean\-Distance implements the Euclidean D\-T using Saito's algorithm. The distance map produced contains the square of the Euclidean distance values.

The algorithm has a o(n$^\wedge$(D+1)) complexity over nxnx...xn images in D dimensions. It is very efficient on relatively small images. Cuisenaire's algorithms should be used instead if n $>$$>$ 500. These are not implemented yet.

For the special case of images where the slice-\/size is a multiple of 2$^\wedge$\-N with a large N (typically for 256x256 slices), Saito's algorithm encounters a lot of cache conflicts during the 3rd iteration which can slow it very significantly. In that case, one should use \-::\-Set\-Algorithm\-To\-Saito\-Cached() instead for better performance.

References\-:

T. Saito and J.\-I. Toriwaki. New algorithms for Euclidean distance transformations of an n-\/dimensional digitised picture with applications. Pattern Recognition, 27(11). pp. 1551--1565, 1994.

O. Cuisenaire. Distance Transformation\-: fast algorithms and applications to medical image processing. Ph\-D Thesis, Universite catholique de Louvain, October 1999. \href{http://ltswww.epfl.ch/~cuisenai/papers/oc_thesis.pdf}{\tt http\-://ltswww.\-epfl.\-ch/$\sim$cuisenai/papers/oc\-\_\-thesis.\-pdf}

To create an instance of class vtk\-Image\-Euclidean\-Distance, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageEuclideanDistance
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Euclidean\-Distance has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Euclidean\-Distance class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Euclidean\-Distance = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Euclidean\-Distance = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Split\-Extent (int split\-Ext\mbox{[}6\mbox{]}, int start\-Ext\mbox{[}6\mbox{]}, int num, int total)} -\/ Used internally for streaming and threads. Splits output update extent into num pieces. This method needs to be called num times. Results must not overlap for consistent starting extent. Subclass can override this method. This method returns the number of peices resulting from a successful split. This can be from 1 to \char`\"{}total\char`\"{}. If 1 is returned, the extent cannot be split.  
\item {\ttfamily obj.\-Set\-Initialize (int )} -\/ Used to set all non-\/zero voxels to Maximum\-Distance before starting the distance transformation. Setting Initialize off keeps the current value in the input image as starting point. This allows to superimpose several distance maps.  
\item {\ttfamily int = obj.\-Get\-Initialize ()} -\/ Used to set all non-\/zero voxels to Maximum\-Distance before starting the distance transformation. Setting Initialize off keeps the current value in the input image as starting point. This allows to superimpose several distance maps.  
\item {\ttfamily obj.\-Initialize\-On ()} -\/ Used to set all non-\/zero voxels to Maximum\-Distance before starting the distance transformation. Setting Initialize off keeps the current value in the input image as starting point. This allows to superimpose several distance maps.  
\item {\ttfamily obj.\-Initialize\-Off ()} -\/ Used to set all non-\/zero voxels to Maximum\-Distance before starting the distance transformation. Setting Initialize off keeps the current value in the input image as starting point. This allows to superimpose several distance maps.  
\item {\ttfamily obj.\-Set\-Consider\-Anisotropy (int )} -\/ Used to define whether Spacing should be used in the computation of the distances  
\item {\ttfamily int = obj.\-Get\-Consider\-Anisotropy ()} -\/ Used to define whether Spacing should be used in the computation of the distances  
\item {\ttfamily obj.\-Consider\-Anisotropy\-On ()} -\/ Used to define whether Spacing should be used in the computation of the distances  
\item {\ttfamily obj.\-Consider\-Anisotropy\-Off ()} -\/ Used to define whether Spacing should be used in the computation of the distances  
\item {\ttfamily obj.\-Set\-Maximum\-Distance (double )} -\/ Any distance bigger than this-\/$>$Maximum\-Distance will not ne computed but set to this-\/$>$Maximum\-Distance instead.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Distance ()} -\/ Any distance bigger than this-\/$>$Maximum\-Distance will not ne computed but set to this-\/$>$Maximum\-Distance instead.  
\item {\ttfamily obj.\-Set\-Algorithm (int )} -\/ Selects a Euclidean D\-T algorithm.
\begin{DoxyEnumerate}
\item Saito
\item Saito-\/cached More algorithms will be added later on.  
\end{DoxyEnumerate}
\item {\ttfamily int = obj.\-Get\-Algorithm ()} -\/ Selects a Euclidean D\-T algorithm.
\begin{DoxyEnumerate}
\item Saito
\item Saito-\/cached More algorithms will be added later on.  
\end{DoxyEnumerate}
\item {\ttfamily obj.\-Set\-Algorithm\-To\-Saito ()} -\/ Selects a Euclidean D\-T algorithm.
\begin{DoxyEnumerate}
\item Saito
\item Saito-\/cached More algorithms will be added later on.  
\end{DoxyEnumerate}
\item {\ttfamily obj.\-Set\-Algorithm\-To\-Saito\-Cached ()}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageeuclideantopolar}{}\section{vtk\-Image\-Euclidean\-To\-Polar}\label{vtkimaging_vtkimageeuclideantopolar}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
For each pixel with vector components x,y, this filter outputs theta in component0, and radius in component1.

To create an instance of class vtk\-Image\-Euclidean\-To\-Polar, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageEuclideanToPolar
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Euclidean\-To\-Polar has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Euclidean\-To\-Polar class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Euclidean\-To\-Polar = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Euclidean\-To\-Polar = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Theta\-Maximum (double )} -\/ Theta is an angle. Maximum specifies when it maps back to 0. Theta\-Maximum defaults to 255 instead of 2\-P\-I, because unsigned char is expected as input. The output type must be the same as input type.  
\item {\ttfamily double = obj.\-Get\-Theta\-Maximum ()} -\/ Theta is an angle. Maximum specifies when it maps back to 0. Theta\-Maximum defaults to 255 instead of 2\-P\-I, because unsigned char is expected as input. The output type must be the same as input type.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageexport}{}\section{vtk\-Image\-Export}\label{vtkimaging_vtkimageexport}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Export provides a way of exporting image data at the end of a pipeline to a third-\/party system or to a simple C array. Applications can use this to get direct access to the image data in memory. A callback interface is provided to allow connection of the V\-T\-K pipeline to a third-\/party pipeline. This interface conforms to the interface of vtk\-Image\-Import. In Python it is possible to use this class to write the image data into a python string that has been pre-\/allocated to be the correct size.

To create an instance of class vtk\-Image\-Export, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageExport
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Export has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Export class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Export = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Export = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Data\-Memory\-Size ()} -\/ Get the number of bytes required for the output C array.  
\item {\ttfamily obj.\-Get\-Data\-Dimensions (int ptr)} -\/ Get the (x,y,z) index dimensions of the data. Please note that C arrays are indexed in decreasing order, i.\-e. array\mbox{[}z\mbox{]}\mbox{[}y\mbox{]}\mbox{[}x\mbox{]}.  
\item {\ttfamily int = obj.\-Get\-Data\-Dimensions ()} -\/ Get the number of scalar components of the data. Please note that when you index into a C array, the scalar component index comes last, i.\-e. array\mbox{[}z\mbox{]}\mbox{[}y\mbox{]}\mbox{[}x\mbox{]}\mbox{[}c\mbox{]}.  
\item {\ttfamily int = obj.\-Get\-Data\-Number\-Of\-Scalar\-Components ()} -\/ Get the number of scalar components of the data. Please note that when you index into a C array, the scalar component index comes last, i.\-e. array\mbox{[}z\mbox{]}\mbox{[}y\mbox{]}\mbox{[}x\mbox{]}\mbox{[}c\mbox{]}.  
\item {\ttfamily int = obj.\-Get\-Data\-Scalar\-Type ()} -\/ Get the scalar type of the data. The scalar type of the C array must match the scalar type of the data.  
\item {\ttfamily string = obj.\-Get\-Data\-Scalar\-Type\-As\-String ()} -\/ Get miscellaneous additional information about the data.  
\item {\ttfamily int = obj.\-Get\-Data\-Extent ()} -\/ Get miscellaneous additional information about the data.  
\item {\ttfamily obj.\-Get\-Data\-Extent (int ptr)} -\/ Get miscellaneous additional information about the data.  
\item {\ttfamily double = obj.\-Get\-Data\-Spacing ()} -\/ Get miscellaneous additional information about the data.  
\item {\ttfamily obj.\-Get\-Data\-Spacing (double ptr)} -\/ Get miscellaneous additional information about the data.  
\item {\ttfamily double = obj.\-Get\-Data\-Origin ()} -\/ Get miscellaneous additional information about the data.  
\item {\ttfamily obj.\-Get\-Data\-Origin (double ptr)} -\/ Get miscellaneous additional information about the data.  
\item {\ttfamily obj.\-Image\-Lower\-Left\-On ()} -\/ Set/\-Get whether the data goes to the exported memory starting in the lower left corner or upper left corner. Default\-: On. When this flag is Off, the image will be flipped vertically before it is exported. W\-A\-R\-N\-I\-N\-G\-: this flag is used only with the Export() method, it is ignored by Get\-Pointer\-To\-Data().  
\item {\ttfamily obj.\-Image\-Lower\-Left\-Off ()} -\/ Set/\-Get whether the data goes to the exported memory starting in the lower left corner or upper left corner. Default\-: On. When this flag is Off, the image will be flipped vertically before it is exported. W\-A\-R\-N\-I\-N\-G\-: this flag is used only with the Export() method, it is ignored by Get\-Pointer\-To\-Data().  
\item {\ttfamily int = obj.\-Get\-Image\-Lower\-Left ()} -\/ Set/\-Get whether the data goes to the exported memory starting in the lower left corner or upper left corner. Default\-: On. When this flag is Off, the image will be flipped vertically before it is exported. W\-A\-R\-N\-I\-N\-G\-: this flag is used only with the Export() method, it is ignored by Get\-Pointer\-To\-Data().  
\item {\ttfamily obj.\-Set\-Image\-Lower\-Left (int )} -\/ Set/\-Get whether the data goes to the exported memory starting in the lower left corner or upper left corner. Default\-: On. When this flag is Off, the image will be flipped vertically before it is exported. W\-A\-R\-N\-I\-N\-G\-: this flag is used only with the Export() method, it is ignored by Get\-Pointer\-To\-Data().  
\item {\ttfamily obj.\-Export ()} -\/ The main interface\-: update the pipeline and export the image to the memory pointed to by Set\-Export\-Void\-Pointer(). You can also specify a void pointer when you call Export().  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageextractcomponents}{}\section{vtk\-Image\-Extract\-Components}\label{vtkimaging_vtkimageextractcomponents}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Extract\-Components takes an input with any number of components and outputs some of them. It does involve a copy of the data.

To create an instance of class vtk\-Image\-Extract\-Components, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageExtractComponents
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Extract\-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\-Image\-Extract\-Components class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Extract\-Components = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Extract\-Components = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Components (int c1)} -\/ Set/\-Get the components to extract.  
\item {\ttfamily obj.\-Set\-Components (int c1, int c2)} -\/ Set/\-Get the components to extract.  
\item {\ttfamily obj.\-Set\-Components (int c1, int c2, int c3)} -\/ Set/\-Get the components to extract.  
\item {\ttfamily int = obj. Get\-Components ()} -\/ Set/\-Get the components to extract.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components ()} -\/ Get the number of components to extract. This is set implicitly by the Set\-Components() method.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagefft}{}\section{vtk\-Image\-F\-F\-T}\label{vtkimaging_vtkimagefft}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-F\-F\-T implements a fast Fourier transform. The input can have real or complex data in any components and data types, but the output is always complex doubles with real values in component0, and imaginary values in component1. The filter is fastest for images that have power of two sizes. The filter uses a butterfly fitlers for each prime factor of the dimension. This makes images with prime number dimensions (i.\-e. 17x17) much slower to compute. Multi dimensional (i.\-e volumes) F\-F\-T's are decomposed so that each axis executes in series.

To create an instance of class vtk\-Image\-F\-F\-T, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageFFT
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-F\-F\-T has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-F\-F\-T class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-F\-F\-T = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-F\-F\-T = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Split\-Extent (int split\-Ext\mbox{[}6\mbox{]}, int start\-Ext\mbox{[}6\mbox{]}, int num, int total)} -\/ Used internally for streaming and threads. Splits output update extent into num pieces. This method needs to be called num times. Results must not overlap for consistent starting extent. Subclass can override this method. This method returns the number of pieces resulting from a successful split. This can be from 1 to \char`\"{}total\char`\"{}. If 1 is returned, the extent cannot be split.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageflip}{}\section{vtk\-Image\-Flip}\label{vtkimaging_vtkimageflip}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Flip will reflect the data along the filtered axis. This filter is actually a thin wrapper around vtk\-Image\-Reslice.

To create an instance of class vtk\-Image\-Flip, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageFlip
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Flip has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Flip class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Flip = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Flip = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Filtered\-Axis (int )} -\/ Specify which axis will be flipped. This must be an integer between 0 (for x) and 2 (for z). Initial value is 0.  
\item {\ttfamily int = obj.\-Get\-Filtered\-Axis ()} -\/ Specify which axis will be flipped. This must be an integer between 0 (for x) and 2 (for z). Initial value is 0.  
\item {\ttfamily obj.\-Set\-Flip\-About\-Origin (int )} -\/ By default the image will be flipped about its center, and the Origin, Spacing and Extent of the output will be identical to the input. However, if you have a coordinate system associated with the image and you want to use the flip to convert +ve values along one axis to -\/ve values (and vice versa) then you actually want to flip the image about coordinate (0,0,0) instead of about the center of the image. This method will adjust the Origin of the output such that the flip occurs about (0,0,0). Note that this method only changes the Origin (and hence the coordinate system) the output data\-: the actual pixel values are the same whether or not this method is used. Also note that the Origin in this method name refers to (0,0,0) in the coordinate system associated with the image, it does not refer to the Origin ivar that is associated with a vtk\-Image\-Data.  
\item {\ttfamily int = obj.\-Get\-Flip\-About\-Origin ()} -\/ By default the image will be flipped about its center, and the Origin, Spacing and Extent of the output will be identical to the input. However, if you have a coordinate system associated with the image and you want to use the flip to convert +ve values along one axis to -\/ve values (and vice versa) then you actually want to flip the image about coordinate (0,0,0) instead of about the center of the image. This method will adjust the Origin of the output such that the flip occurs about (0,0,0). Note that this method only changes the Origin (and hence the coordinate system) the output data\-: the actual pixel values are the same whether or not this method is used. Also note that the Origin in this method name refers to (0,0,0) in the coordinate system associated with the image, it does not refer to the Origin ivar that is associated with a vtk\-Image\-Data.  
\item {\ttfamily obj.\-Flip\-About\-Origin\-On ()} -\/ By default the image will be flipped about its center, and the Origin, Spacing and Extent of the output will be identical to the input. However, if you have a coordinate system associated with the image and you want to use the flip to convert +ve values along one axis to -\/ve values (and vice versa) then you actually want to flip the image about coordinate (0,0,0) instead of about the center of the image. This method will adjust the Origin of the output such that the flip occurs about (0,0,0). Note that this method only changes the Origin (and hence the coordinate system) the output data\-: the actual pixel values are the same whether or not this method is used. Also note that the Origin in this method name refers to (0,0,0) in the coordinate system associated with the image, it does not refer to the Origin ivar that is associated with a vtk\-Image\-Data.  
\item {\ttfamily obj.\-Flip\-About\-Origin\-Off ()} -\/ By default the image will be flipped about its center, and the Origin, Spacing and Extent of the output will be identical to the input. However, if you have a coordinate system associated with the image and you want to use the flip to convert +ve values along one axis to -\/ve values (and vice versa) then you actually want to flip the image about coordinate (0,0,0) instead of about the center of the image. This method will adjust the Origin of the output such that the flip occurs about (0,0,0). Note that this method only changes the Origin (and hence the coordinate system) the output data\-: the actual pixel values are the same whether or not this method is used. Also note that the Origin in this method name refers to (0,0,0) in the coordinate system associated with the image, it does not refer to the Origin ivar that is associated with a vtk\-Image\-Data.  
\item {\ttfamily obj.\-Set\-Filtered\-Axes (int axis)} -\/ Keep the mis-\/named Axes variations around for compatibility with old scripts. Axis is singular, not plural...  
\item {\ttfamily int = obj.\-Get\-Filtered\-Axes ()} -\/ Preserve\-Image\-Extent\-Off wasn't covered by test scripts and its implementation was broken. It is deprecated now and it has no effect (i.\-e. the Image\-Extent is always preserved).  
\item {\ttfamily obj.\-Set\-Preserve\-Image\-Extent (int )} -\/ Preserve\-Image\-Extent\-Off wasn't covered by test scripts and its implementation was broken. It is deprecated now and it has no effect (i.\-e. the Image\-Extent is always preserved).  
\item {\ttfamily int = obj.\-Get\-Preserve\-Image\-Extent ()} -\/ Preserve\-Image\-Extent\-Off wasn't covered by test scripts and its implementation was broken. It is deprecated now and it has no effect (i.\-e. the Image\-Extent is always preserved).  
\item {\ttfamily obj.\-Preserve\-Image\-Extent\-On ()} -\/ Preserve\-Image\-Extent\-Off wasn't covered by test scripts and its implementation was broken. It is deprecated now and it has no effect (i.\-e. the Image\-Extent is always preserved).  
\item {\ttfamily obj.\-Preserve\-Image\-Extent\-Off ()} -\/ Preserve\-Image\-Extent\-Off wasn't covered by test scripts and its implementation was broken. It is deprecated now and it has no effect (i.\-e. the Image\-Extent is always preserved).  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagefouriercenter}{}\section{vtk\-Image\-Fourier\-Center}\label{vtkimaging_vtkimagefouriercenter}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Is used for dispaying images in frequency space. F\-F\-T converts spatial images into frequency space, but puts the zero frequency at the origin. This filter shifts the zero frequency to the center of the image. Input and output are assumed to be doubles.

To create an instance of class vtk\-Image\-Fourier\-Center, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageFourierCenter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Fourier\-Center has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Fourier\-Center class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Fourier\-Center = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Fourier\-Center = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagefourierfilter}{}\section{vtk\-Image\-Fourier\-Filter}\label{vtkimaging_vtkimagefourierfilter}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Fourier\-Filter is a class of filters that use complex numbers this superclass is a container for methods that manipulate these structure including fast Fourier transforms. Complex numbers may become a class. This should really be a helper class.

To create an instance of class vtk\-Image\-Fourier\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageFourierFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Fourier\-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\-Fourier\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Fourier\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Fourier\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagegaussiansmooth}{}\section{vtk\-Image\-Gaussian\-Smooth}\label{vtkimaging_vtkimagegaussiansmooth}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Gaussian\-Smooth implements a convolution of the input image with a gaussian. Supports from one to three dimensional convolutions.

To create an instance of class vtk\-Image\-Gaussian\-Smooth, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageGaussianSmooth
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Gaussian\-Smooth has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Gaussian\-Smooth class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Gaussian\-Smooth = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Gaussian\-Smooth = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Standard\-Deviations (double , double , double )} -\/ Sets/\-Gets the Standard deviation of the gaussian in pixel units.  
\item {\ttfamily obj.\-Set\-Standard\-Deviations (double a\mbox{[}3\mbox{]})} -\/ Sets/\-Gets the Standard deviation of the gaussian in pixel units.  
\item {\ttfamily obj.\-Set\-Standard\-Deviation (double std)} -\/ Sets/\-Gets the Standard deviation of the gaussian in pixel units.  
\item {\ttfamily obj.\-Set\-Standard\-Deviations (double a, double b)} -\/ Sets/\-Gets the Standard deviation of the gaussian in pixel units.  
\item {\ttfamily double = obj. Get\-Standard\-Deviations ()} -\/ Sets/\-Gets the Standard deviation of the gaussian in pixel units.  
\item {\ttfamily obj.\-Set\-Standard\-Deviation (double a, double b)} -\/ Sets/\-Gets the Standard deviation of the gaussian in pixel units. These methods are provided for compatibility with old scripts  
\item {\ttfamily obj.\-Set\-Standard\-Deviation (double a, double b, double c)} -\/ Sets/\-Gets the Radius Factors of the gaussian (no unit). The radius factors determine how far out the gaussian kernel will go before being clamped to zero.  
\item {\ttfamily obj.\-Set\-Radius\-Factors (double , double , double )} -\/ Sets/\-Gets the Radius Factors of the gaussian (no unit). The radius factors determine how far out the gaussian kernel will go before being clamped to zero.  
\item {\ttfamily obj.\-Set\-Radius\-Factors (double a\mbox{[}3\mbox{]})} -\/ Sets/\-Gets the Radius Factors of the gaussian (no unit). The radius factors determine how far out the gaussian kernel will go before being clamped to zero.  
\item {\ttfamily obj.\-Set\-Radius\-Factors (double f, double f2)} -\/ Sets/\-Gets the Radius Factors of the gaussian (no unit). The radius factors determine how far out the gaussian kernel will go before being clamped to zero.  
\item {\ttfamily obj.\-Set\-Radius\-Factor (double f)} -\/ Sets/\-Gets the Radius Factors of the gaussian (no unit). The radius factors determine how far out the gaussian kernel will go before being clamped to zero.  
\item {\ttfamily double = obj. Get\-Radius\-Factors ()} -\/ Sets/\-Gets the Radius Factors of the gaussian (no unit). The radius factors determine how far out the gaussian kernel will go before being clamped to zero.  
\item {\ttfamily obj.\-Set\-Dimensionality (int )} -\/ Set/\-Get the dimensionality of this filter. This determines whether a one, two, or three dimensional gaussian is performed.  
\item {\ttfamily int = obj.\-Get\-Dimensionality ()} -\/ Set/\-Get the dimensionality of this filter. This determines whether a one, two, or three dimensional gaussian is performed.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagegaussiansource}{}\section{vtk\-Image\-Gaussian\-Source}\label{vtkimaging_vtkimagegaussiansource}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Gaussian\-Source just produces images with pixel values determined by a Gaussian.

To create an instance of class vtk\-Image\-Gaussian\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageGaussianSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Gaussian\-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\-Image\-Gaussian\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Gaussian\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Gaussian\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Whole\-Extent (int x\-Minx, int x\-Max, int y\-Min, int y\-Max, int z\-Min, int z\-Max)} -\/ Set/\-Get the extent of the whole output image.  
\item {\ttfamily obj.\-Set\-Center (double , double , double )} -\/ Set/\-Get the center of the Gaussian.  
\item {\ttfamily obj.\-Set\-Center (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the center of the Gaussian.  
\item {\ttfamily double = obj. Get\-Center ()} -\/ Set/\-Get the center of the Gaussian.  
\item {\ttfamily obj.\-Set\-Maximum (double )} -\/ Set/\-Get the Maximum value of the gaussian  
\item {\ttfamily double = obj.\-Get\-Maximum ()} -\/ Set/\-Get the Maximum value of the gaussian  
\item {\ttfamily obj.\-Set\-Standard\-Deviation (double )} -\/ Set/\-Get the standard deviation of the gaussian  
\item {\ttfamily double = obj.\-Get\-Standard\-Deviation ()} -\/ Set/\-Get the standard deviation of the gaussian  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagegradient}{}\section{vtk\-Image\-Gradient}\label{vtkimaging_vtkimagegradient}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Gradient computes the gradient vector of an image. The vector results are stored as scalar components. The Dimensionality determines whether to perform a 2d or 3d gradient. The default is two dimensional X\-Y gradient. Output\-Scalar\-Type is always double. Gradient is computed using central differences.

To create an instance of class vtk\-Image\-Gradient, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageGradient
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-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\-Image\-Gradient class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Gradient = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Gradient = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Dimensionality (int )} -\/ Determines how the input is interpreted (set of 2d slices ...)  
\item {\ttfamily int = obj.\-Get\-Dimensionality\-Min\-Value ()} -\/ Determines how the input is interpreted (set of 2d slices ...)  
\item {\ttfamily int = obj.\-Get\-Dimensionality\-Max\-Value ()} -\/ Determines how the input is interpreted (set of 2d slices ...)  
\item {\ttfamily int = obj.\-Get\-Dimensionality ()} -\/ Determines how the input is interpreted (set of 2d slices ...)  
\item {\ttfamily obj.\-Set\-Handle\-Boundaries (int )} -\/ Get/\-Set whether to handle boundaries. If enabled, boundary pixels are treated as duplicated so that central differencing works for the boundary pixels. If disabled, the output whole extent of the image is reduced by one pixel.  
\item {\ttfamily int = obj.\-Get\-Handle\-Boundaries ()} -\/ Get/\-Set whether to handle boundaries. If enabled, boundary pixels are treated as duplicated so that central differencing works for the boundary pixels. If disabled, the output whole extent of the image is reduced by one pixel.  
\item {\ttfamily obj.\-Handle\-Boundaries\-On ()} -\/ Get/\-Set whether to handle boundaries. If enabled, boundary pixels are treated as duplicated so that central differencing works for the boundary pixels. If disabled, the output whole extent of the image is reduced by one pixel.  
\item {\ttfamily obj.\-Handle\-Boundaries\-Off ()} -\/ Get/\-Set whether to handle boundaries. If enabled, boundary pixels are treated as duplicated so that central differencing works for the boundary pixels. If disabled, the output whole extent of the image is reduced by one pixel.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagegradientmagnitude}{}\section{vtk\-Image\-Gradient\-Magnitude}\label{vtkimaging_vtkimagegradientmagnitude}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Gradient\-Magnitude computes the gradient magnitude of an image. Setting the dimensionality determines whether the gradient is computed on 2\-D images, or 3\-D volumes. The default is two dimensional X\-Y images.

To create an instance of class vtk\-Image\-Gradient\-Magnitude, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageGradientMagnitude
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Gradient\-Magnitude has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Gradient\-Magnitude class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Gradient\-Magnitude = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Gradient\-Magnitude = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Handle\-Boundaries (int )} -\/ If \char`\"{}\-Handle\-Boundaries\-On\char`\"{} then boundary pixels are duplicated So central differences can get values.  
\item {\ttfamily int = obj.\-Get\-Handle\-Boundaries ()} -\/ If \char`\"{}\-Handle\-Boundaries\-On\char`\"{} then boundary pixels are duplicated So central differences can get values.  
\item {\ttfamily obj.\-Handle\-Boundaries\-On ()} -\/ If \char`\"{}\-Handle\-Boundaries\-On\char`\"{} then boundary pixels are duplicated So central differences can get values.  
\item {\ttfamily obj.\-Handle\-Boundaries\-Off ()} -\/ If \char`\"{}\-Handle\-Boundaries\-On\char`\"{} then boundary pixels are duplicated So central differences can get values.  
\item {\ttfamily obj.\-Set\-Dimensionality (int )} -\/ Determines how the input is interpreted (set of 2d slices ...)  
\item {\ttfamily int = obj.\-Get\-Dimensionality\-Min\-Value ()} -\/ Determines how the input is interpreted (set of 2d slices ...)  
\item {\ttfamily int = obj.\-Get\-Dimensionality\-Max\-Value ()} -\/ Determines how the input is interpreted (set of 2d slices ...)  
\item {\ttfamily int = obj.\-Get\-Dimensionality ()} -\/ Determines how the input is interpreted (set of 2d slices ...)  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagegridsource}{}\section{vtk\-Image\-Grid\-Source}\label{vtkimaging_vtkimagegridsource}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Grid\-Source produces an image of a grid. The default output type is double.

To create an instance of class vtk\-Image\-Grid\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageGridSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Grid\-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\-Image\-Grid\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Grid\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Grid\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Grid\-Spacing (int , int , int )} -\/ Set/\-Get the grid spacing in pixel units. Default (10,10,0). A value of zero means no grid.  
\item {\ttfamily obj.\-Set\-Grid\-Spacing (int a\mbox{[}3\mbox{]})} -\/ Set/\-Get the grid spacing in pixel units. Default (10,10,0). A value of zero means no grid.  
\item {\ttfamily int = obj. Get\-Grid\-Spacing ()} -\/ Set/\-Get the grid spacing in pixel units. Default (10,10,0). A value of zero means no grid.  
\item {\ttfamily obj.\-Set\-Grid\-Origin (int , int , int )} -\/ Set/\-Get the grid origin, in ijk integer values. Default (0,0,0).  
\item {\ttfamily obj.\-Set\-Grid\-Origin (int a\mbox{[}3\mbox{]})} -\/ Set/\-Get the grid origin, in ijk integer values. Default (0,0,0).  
\item {\ttfamily int = obj. Get\-Grid\-Origin ()} -\/ Set/\-Get the grid origin, in ijk integer values. Default (0,0,0).  
\item {\ttfamily obj.\-Set\-Line\-Value (double )} -\/ Set the grey level of the lines. Default 1.\-0.  
\item {\ttfamily double = obj.\-Get\-Line\-Value ()} -\/ Set the grey level of the lines. Default 1.\-0.  
\item {\ttfamily obj.\-Set\-Fill\-Value (double )} -\/ Set the grey level of the fill. Default 0.\-0.  
\item {\ttfamily double = obj.\-Get\-Fill\-Value ()} -\/ Set the grey level of the fill. Default 0.\-0.  
\item {\ttfamily obj.\-Set\-Data\-Scalar\-Type (int )} -\/ Set/\-Get the data type of pixels in the imported data. As a convenience, the Output\-Scalar\-Type is set to the same value.  
\item {\ttfamily obj.\-Set\-Data\-Scalar\-Type\-To\-Double ()} -\/ Set/\-Get the data type of pixels in the imported data. As a convenience, the Output\-Scalar\-Type is set to the same value.  
\item {\ttfamily obj.\-Set\-Data\-Scalar\-Type\-To\-Int ()} -\/ Set/\-Get the data type of pixels in the imported data. As a convenience, the Output\-Scalar\-Type is set to the same value.  
\item {\ttfamily obj.\-Set\-Data\-Scalar\-Type\-To\-Short ()} -\/ Set/\-Get the data type of pixels in the imported data. As a convenience, the Output\-Scalar\-Type is set to the same value.  
\item {\ttfamily obj.\-Set\-Data\-Scalar\-Type\-To\-Unsigned\-Short ()} -\/ Set/\-Get the data type of pixels in the imported data. As a convenience, the Output\-Scalar\-Type is set to the same value.  
\item {\ttfamily obj.\-Set\-Data\-Scalar\-Type\-To\-Unsigned\-Char ()} -\/ Set/\-Get the data type of pixels in the imported data. As a convenience, the Output\-Scalar\-Type is set to the same value.  
\item {\ttfamily int = obj.\-Get\-Data\-Scalar\-Type ()} -\/ Set/\-Get the data type of pixels in the imported data. As a convenience, the Output\-Scalar\-Type is set to the same value.  
\item {\ttfamily string = obj.\-Get\-Data\-Scalar\-Type\-As\-String ()} -\/ Set/\-Get the extent of the whole output image, Default\-: (0,255,0,255,0,0)  
\item {\ttfamily obj.\-Set\-Data\-Extent (int , int , int , int , int , int )} -\/ Set/\-Get the extent of the whole output image, Default\-: (0,255,0,255,0,0)  
\item {\ttfamily obj.\-Set\-Data\-Extent (int a\mbox{[}6\mbox{]})} -\/ Set/\-Get the extent of the whole output image, Default\-: (0,255,0,255,0,0)  
\item {\ttfamily int = obj. Get\-Data\-Extent ()} -\/ Set/\-Get the extent of the whole output image, Default\-: (0,255,0,255,0,0)  
\item {\ttfamily obj.\-Set\-Data\-Spacing (double , double , double )} -\/ Set/\-Get the pixel spacing.  
\item {\ttfamily obj.\-Set\-Data\-Spacing (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the pixel spacing.  
\item {\ttfamily double = obj. Get\-Data\-Spacing ()} -\/ Set/\-Get the pixel spacing.  
\item {\ttfamily obj.\-Set\-Data\-Origin (double , double , double )} -\/ Set/\-Get the origin of the data.  
\item {\ttfamily obj.\-Set\-Data\-Origin (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the origin of the data.  
\item {\ttfamily double = obj. Get\-Data\-Origin ()} -\/ Set/\-Get the origin of the data.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagehsitorgb}{}\section{vtk\-Image\-H\-S\-I\-To\-R\-G\-B}\label{vtkimaging_vtkimagehsitorgb}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
For each pixel with hue, saturation and intensity components this filter outputs the color coded as red, green, blue. Output type must be the same as input type.

To create an instance of class vtk\-Image\-H\-S\-I\-To\-R\-G\-B, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageHSIToRGB
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-H\-S\-I\-To\-R\-G\-B has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-H\-S\-I\-To\-R\-G\-B class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-H\-S\-I\-To\-R\-G\-B = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-H\-S\-I\-To\-R\-G\-B = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Maximum (double )} -\/ Hue is an angle. Maximum specifies when it maps back to 0. Hue\-Maximum defaults to 255 instead of 2\-P\-I, because unsigned char is expected as input. Maximum also specifies the maximum of the Saturation, and R, G, B.  
\item {\ttfamily double = obj.\-Get\-Maximum ()} -\/ Hue is an angle. Maximum specifies when it maps back to 0. Hue\-Maximum defaults to 255 instead of 2\-P\-I, because unsigned char is expected as input. Maximum also specifies the maximum of the Saturation, and R, G, B.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagehsvtorgb}{}\section{vtk\-Image\-H\-S\-V\-To\-R\-G\-B}\label{vtkimaging_vtkimagehsvtorgb}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
For each pixel with hue, saturation and value components this filter outputs the color coded as red, green, blue. Output type must be the same as input type.

To create an instance of class vtk\-Image\-H\-S\-V\-To\-R\-G\-B, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageHSVToRGB
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-H\-S\-V\-To\-R\-G\-B has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-H\-S\-V\-To\-R\-G\-B class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-H\-S\-V\-To\-R\-G\-B = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-H\-S\-V\-To\-R\-G\-B = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Maximum (double )} -\/ Hue is an angle. Maximum specifies when it maps back to 0. Hue\-Maximum defaults to 255 instead of 2\-P\-I, because unsigned char is expected as input. Maximum also specifies the maximum of the Saturation, and R, G, B.  
\item {\ttfamily double = obj.\-Get\-Maximum ()} -\/ Hue is an angle. Maximum specifies when it maps back to 0. Hue\-Maximum defaults to 255 instead of 2\-P\-I, because unsigned char is expected as input. Maximum also specifies the maximum of the Saturation, and R, G, B.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagehybridmedian2d}{}\section{vtk\-Image\-Hybrid\-Median2\-D}\label{vtkimaging_vtkimagehybridmedian2d}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Hybrid\-Median2\-D is a median filter that preserves thin lines and corners. It operates on a 5x5 pixel neighborhood. It computes two values initially\-: the median of the + neighbors and the median of the x neighbors. It then computes the median of these two values plus the center pixel. This result of this second median is the output pixel value.

To create an instance of class vtk\-Image\-Hybrid\-Median2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageHybridMedian2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Hybrid\-Median2\-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\-Image\-Hybrid\-Median2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Hybrid\-Median2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Hybrid\-Median2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageidealhighpass}{}\section{vtk\-Image\-Ideal\-High\-Pass}\label{vtkimaging_vtkimageidealhighpass}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This filter only works on an image after it has been converted to frequency domain by a vtk\-Image\-F\-F\-T filter. A vtk\-Image\-R\-F\-F\-T filter can be used to convert the output back into the spatial domain. vtk\-Image\-Ideal\-High\-Pass just sets a portion of the image to zero. The sharp cutoff in the frequence domain produces ringing in the spatial domain. Input and Output must be doubles. Dimensionality is set when the axes are set. Defaults to 2\-D on X and Y axes.

To create an instance of class vtk\-Image\-Ideal\-High\-Pass, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageIdealHighPass
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Ideal\-High\-Pass has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Ideal\-High\-Pass class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Ideal\-High\-Pass = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Ideal\-High\-Pass = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Cut\-Off (double , double , double )} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily obj.\-Set\-Cut\-Off (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily obj.\-Set\-Cut\-Off (double v)} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily obj.\-Set\-X\-Cut\-Off (double v)} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily obj.\-Set\-Y\-Cut\-Off (double v)} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily obj.\-Set\-Z\-Cut\-Off (double v)} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily double = obj. Get\-Cut\-Off ()} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily double = obj.\-Get\-X\-Cut\-Off ()} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily double = obj.\-Get\-Y\-Cut\-Off ()} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily double = obj.\-Get\-Z\-Cut\-Off ()}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageideallowpass}{}\section{vtk\-Image\-Ideal\-Low\-Pass}\label{vtkimaging_vtkimageideallowpass}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This filter only works on an image after it has been converted to frequency domain by a vtk\-Image\-F\-F\-T filter. A vtk\-Image\-R\-F\-F\-T filter can be used to convert the output back into the spatial domain. vtk\-Image\-Ideal\-Low\-Pass just sets a portion of the image to zero. The result is an image with a lot of ringing. Input and Output must be doubles. Dimensionality is set when the axes are set. Defaults to 2\-D on X and Y axes.

To create an instance of class vtk\-Image\-Ideal\-Low\-Pass, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageIdealLowPass
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Ideal\-Low\-Pass has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Ideal\-Low\-Pass class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Ideal\-Low\-Pass = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Ideal\-Low\-Pass = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Cut\-Off (double , double , double )} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily obj.\-Set\-Cut\-Off (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily obj.\-Set\-Cut\-Off (double v)} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily obj.\-Set\-X\-Cut\-Off (double v)} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily obj.\-Set\-Y\-Cut\-Off (double v)} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily obj.\-Set\-Z\-Cut\-Off (double v)} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily double = obj. Get\-Cut\-Off ()} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily double = obj.\-Get\-X\-Cut\-Off ()} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily double = obj.\-Get\-Y\-Cut\-Off ()} -\/ Set/\-Get the cutoff frequency for each axis. The values are specified in the order X, Y, Z, Time. Units\-: Cycles per world unit (as defined by the data spacing).  
\item {\ttfamily double = obj.\-Get\-Z\-Cut\-Off ()}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageimport}{}\section{vtk\-Image\-Import}\label{vtkimaging_vtkimageimport}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Import provides methods needed to import image data from a source independent of V\-T\-K, such as a simple C array or a third-\/party pipeline. Note that the V\-T\-K convention is for the image voxel index (0,0,0) to be the lower-\/left corner of the image, while most 2\-D image formats use the upper-\/left corner. You can use vtk\-Image\-Flip to correct the orientation after the image has been loaded into V\-T\-K. Note that is also possible to import the raw data from a Python string instead of from a C array. The array applies on scalar point data only, not on cell data.

To create an instance of class vtk\-Image\-Import, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageImport
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Import has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Import class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Import = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Import = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Data\-Scalar\-Type (int )} -\/ Set/\-Get the data type of pixels in the imported data. This is used as the scalar type of the Output. Default\-: Short.  
\item {\ttfamily obj.\-Set\-Data\-Scalar\-Type\-To\-Double ()} -\/ Set/\-Get the data type of pixels in the imported data. This is used as the scalar type of the Output. Default\-: Short.  
\item {\ttfamily obj.\-Set\-Data\-Scalar\-Type\-To\-Float ()} -\/ Set/\-Get the data type of pixels in the imported data. This is used as the scalar type of the Output. Default\-: Short.  
\item {\ttfamily obj.\-Set\-Data\-Scalar\-Type\-To\-Int ()} -\/ Set/\-Get the data type of pixels in the imported data. This is used as the scalar type of the Output. Default\-: Short.  
\item {\ttfamily obj.\-Set\-Data\-Scalar\-Type\-To\-Short ()} -\/ Set/\-Get the data type of pixels in the imported data. This is used as the scalar type of the Output. Default\-: Short.  
\item {\ttfamily obj.\-Set\-Data\-Scalar\-Type\-To\-Unsigned\-Short ()} -\/ Set/\-Get the data type of pixels in the imported data. This is used as the scalar type of the Output. Default\-: Short.  
\item {\ttfamily obj.\-Set\-Data\-Scalar\-Type\-To\-Unsigned\-Char ()} -\/ Set/\-Get the data type of pixels in the imported data. This is used as the scalar type of the Output. Default\-: Short.  
\item {\ttfamily int = obj.\-Get\-Data\-Scalar\-Type ()} -\/ Set/\-Get the data type of pixels in the imported data. This is used as the scalar type of the Output. Default\-: Short.  
\item {\ttfamily string = obj.\-Get\-Data\-Scalar\-Type\-As\-String ()} -\/ Set/\-Get the number of scalar components, for R\-G\-B images this must be 3. Default\-: 1.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Scalar\-Components (int )} -\/ Set/\-Get the number of scalar components, for R\-G\-B images this must be 3. Default\-: 1.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Scalar\-Components ()} -\/ Set/\-Get the number of scalar components, for R\-G\-B images this must be 3. Default\-: 1.  
\item {\ttfamily obj.\-Set\-Data\-Extent (int , int , int , int , int , int )} -\/ Get/\-Set the extent of the data buffer. The dimensions of your data must be equal to (extent\mbox{[}1\mbox{]}-\/extent\mbox{[}0\mbox{]}+1) $\ast$ (extent\mbox{[}3\mbox{]}-\/extent\mbox{[}2\mbox{]}+1) $\ast$ (extent\mbox{[}5\mbox{]}-\/\-Data\-Extent\mbox{[}4\mbox{]}+1). For example, for a 2\-D image use (0,width-\/1, 0,height-\/1, 0,0).  
\item {\ttfamily obj.\-Set\-Data\-Extent (int a\mbox{[}6\mbox{]})} -\/ Get/\-Set the extent of the data buffer. The dimensions of your data must be equal to (extent\mbox{[}1\mbox{]}-\/extent\mbox{[}0\mbox{]}+1) $\ast$ (extent\mbox{[}3\mbox{]}-\/extent\mbox{[}2\mbox{]}+1) $\ast$ (extent\mbox{[}5\mbox{]}-\/\-Data\-Extent\mbox{[}4\mbox{]}+1). For example, for a 2\-D image use (0,width-\/1, 0,height-\/1, 0,0).  
\item {\ttfamily int = obj. Get\-Data\-Extent ()} -\/ Get/\-Set the extent of the data buffer. The dimensions of your data must be equal to (extent\mbox{[}1\mbox{]}-\/extent\mbox{[}0\mbox{]}+1) $\ast$ (extent\mbox{[}3\mbox{]}-\/extent\mbox{[}2\mbox{]}+1) $\ast$ (extent\mbox{[}5\mbox{]}-\/\-Data\-Extent\mbox{[}4\mbox{]}+1). For example, for a 2\-D image use (0,width-\/1, 0,height-\/1, 0,0).  
\item {\ttfamily obj.\-Set\-Data\-Extent\-To\-Whole\-Extent ()} -\/ Set/\-Get the spacing (typically in mm) between image voxels. Default\-: (1.\-0, 1.\-0, 1.\-0).  
\item {\ttfamily obj.\-Set\-Data\-Spacing (double , double , double )} -\/ Set/\-Get the spacing (typically in mm) between image voxels. Default\-: (1.\-0, 1.\-0, 1.\-0).  
\item {\ttfamily obj.\-Set\-Data\-Spacing (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the spacing (typically in mm) between image voxels. Default\-: (1.\-0, 1.\-0, 1.\-0).  
\item {\ttfamily double = obj. Get\-Data\-Spacing ()} -\/ Set/\-Get the spacing (typically in mm) between image voxels. Default\-: (1.\-0, 1.\-0, 1.\-0).  
\item {\ttfamily obj.\-Set\-Data\-Origin (double , double , double )} -\/ Set/\-Get the origin of the data, i.\-e. the coordinates (usually in mm) of voxel (0,0,0). Default\-: (0.\-0, 0.\-0, 0.\-0).  
\item {\ttfamily obj.\-Set\-Data\-Origin (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the origin of the data, i.\-e. the coordinates (usually in mm) of voxel (0,0,0). Default\-: (0.\-0, 0.\-0, 0.\-0).  
\item {\ttfamily double = obj. Get\-Data\-Origin ()} -\/ Set/\-Get the origin of the data, i.\-e. the coordinates (usually in mm) of voxel (0,0,0). Default\-: (0.\-0, 0.\-0, 0.\-0).  
\item {\ttfamily obj.\-Set\-Whole\-Extent (int , int , int , int , int , int )} -\/ Get/\-Set the whole extent of the image. This is the largest possible extent. Set the Data\-Extent to the extent of the image in the buffer pointed to by the Import\-Void\-Pointer.  
\item {\ttfamily obj.\-Set\-Whole\-Extent (int a\mbox{[}6\mbox{]})} -\/ Get/\-Set the whole extent of the image. This is the largest possible extent. Set the Data\-Extent to the extent of the image in the buffer pointed to by the Import\-Void\-Pointer.  
\item {\ttfamily int = obj. Get\-Whole\-Extent ()} -\/ Get/\-Set the whole extent of the image. This is the largest possible extent. Set the Data\-Extent to the extent of the image in the buffer pointed to by the Import\-Void\-Pointer.  
\item {\ttfamily obj.\-Set\-Scalar\-Array\-Name (string )} -\/ Set/get the scalar array name for this data set. Initial value is \char`\"{}scalars\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-Scalar\-Array\-Name ()} -\/ Set/get the scalar array name for this data set. Initial value is \char`\"{}scalars\char`\"{}.  
\item {\ttfamily int = obj.\-Invoke\-Pipeline\-Modified\-Callbacks ()} -\/ Invoke the appropriate callbacks  
\item {\ttfamily obj.\-Invoke\-Update\-Information\-Callbacks ()} -\/ Invoke the appropriate callbacks  
\item {\ttfamily obj.\-Invoke\-Execute\-Information\-Callbacks ()} -\/ Invoke the appropriate callbacks  
\item {\ttfamily obj.\-Invoke\-Execute\-Data\-Callbacks ()} -\/ Invoke the appropriate callbacks  
\item {\ttfamily obj.\-Legacy\-Check\-Whole\-Extent ()} -\/ Invoke the appropriate callbacks  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageimportexecutive}{}\section{vtk\-Image\-Import\-Executive}\label{vtkimaging_vtkimageimportexecutive}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Import\-Executive

To create an instance of class vtk\-Image\-Import\-Executive, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageImportExecutive
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Import\-Executive has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Import\-Executive class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Import\-Executive = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Import\-Executive = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageislandremoval2d}{}\section{vtk\-Image\-Island\-Removal2\-D}\label{vtkimaging_vtkimageislandremoval2d}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Island\-Removal2\-D computes the area of separate islands in a mask image. It removes any island that has less than Area\-Threshold pixels. Output has the same Scalar\-Type as input. It generates the whole 2\-D output image for any output request.

To create an instance of class vtk\-Image\-Island\-Removal2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageIslandRemoval2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Island\-Removal2\-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\-Image\-Island\-Removal2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Constructor\-: Sets default filter to be identity.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Constructor\-: Sets default filter to be identity.  
\item {\ttfamily vtk\-Image\-Island\-Removal2\-D = obj.\-New\-Instance ()} -\/ Constructor\-: Sets default filter to be identity.  
\item {\ttfamily vtk\-Image\-Island\-Removal2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Constructor\-: Sets default filter to be identity.  
\item {\ttfamily obj.\-Set\-Area\-Threshold (int )} -\/ Set/\-Get the cutoff area for removal  
\item {\ttfamily int = obj.\-Get\-Area\-Threshold ()} -\/ Set/\-Get the cutoff area for removal  
\item {\ttfamily obj.\-Set\-Square\-Neighborhood (int )} -\/ Set/\-Get whether to use 4 or 8 neighbors  
\item {\ttfamily int = obj.\-Get\-Square\-Neighborhood ()} -\/ Set/\-Get whether to use 4 or 8 neighbors  
\item {\ttfamily obj.\-Square\-Neighborhood\-On ()} -\/ Set/\-Get whether to use 4 or 8 neighbors  
\item {\ttfamily obj.\-Square\-Neighborhood\-Off ()} -\/ Set/\-Get whether to use 4 or 8 neighbors  
\item {\ttfamily obj.\-Set\-Island\-Value (double )} -\/ Set/\-Get the value to remove.  
\item {\ttfamily double = obj.\-Get\-Island\-Value ()} -\/ Set/\-Get the value to remove.  
\item {\ttfamily obj.\-Set\-Replace\-Value (double )} -\/ Set/\-Get the value to put in the place of removed pixels.  
\item {\ttfamily double = obj.\-Get\-Replace\-Value ()} -\/ Set/\-Get the value to put in the place of removed pixels.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageiteratefilter}{}\section{vtk\-Image\-Iterate\-Filter}\label{vtkimaging_vtkimageiteratefilter}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Iterate\-Filter is a filter superclass that supports calling execute multiple times per update. The largest hack/open issue is that the input and output caches are temporarily changed to \char`\"{}fool\char`\"{} the subclasses. I believe the correct solution is to pass the in and out cache to the subclasses methods as arguments. Now the data is passes. Can the caches be passed, and data retrieved from the cache?

To create an instance of class vtk\-Image\-Iterate\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageIterateFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Iterate\-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\-Iterate\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Iterate\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Iterate\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Iteration ()} -\/ Get which iteration is current being performed. Normally the user will not access this method.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Iterations ()} -\/ Get which iteration is current being performed. Normally the user will not access this method.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagelaplacian}{}\section{vtk\-Image\-Laplacian}\label{vtkimaging_vtkimagelaplacian}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Laplacian computes the Laplacian (like a second derivative) of a scalar image. The operation is the same as taking the divergence after a gradient. Boundaries are handled, so the input is the same as the output. Dimensionality determines how the input regions are interpreted. (images, or volumes). The Dimensionality defaults to two.

To create an instance of class vtk\-Image\-Laplacian, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageLaplacian
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Laplacian has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Laplacian class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Laplacian = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Laplacian = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Dimensionality (int )} -\/ Determines how the input is interpreted (set of 2d slices ...)  
\item {\ttfamily int = obj.\-Get\-Dimensionality\-Min\-Value ()} -\/ Determines how the input is interpreted (set of 2d slices ...)  
\item {\ttfamily int = obj.\-Get\-Dimensionality\-Max\-Value ()} -\/ Determines how the input is interpreted (set of 2d slices ...)  
\item {\ttfamily int = obj.\-Get\-Dimensionality ()} -\/ Determines how the input is interpreted (set of 2d slices ...)  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagelogarithmicscale}{}\section{vtk\-Image\-Logarithmic\-Scale}\label{vtkimaging_vtkimagelogarithmicscale}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Logarithmic\-Scale passes each pixel through the function c$\ast$log(1+x). It also handles negative values with the function -\/c$\ast$log(1-\/x).

To create an instance of class vtk\-Image\-Logarithmic\-Scale, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageLogarithmicScale
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Logarithmic\-Scale has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Logarithmic\-Scale class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Logarithmic\-Scale = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Logarithmic\-Scale = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Constant (double )} -\/ Set/\-Get the scale factor for the logarithmic function.  
\item {\ttfamily double = obj.\-Get\-Constant ()} -\/ Set/\-Get the scale factor for the logarithmic function.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagelogic}{}\section{vtk\-Image\-Logic}\label{vtkimaging_vtkimagelogic}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Logic implements basic logic operations. Set\-Operation is used to select the filter's behavior. The filter can take two or one input. Inputs must have the same type.

To create an instance of class vtk\-Image\-Logic, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageLogic
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Logic has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Logic class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Logic = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Logic = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Operation (int )} -\/ Set/\-Get the Operation to perform.  
\item {\ttfamily int = obj.\-Get\-Operation ()} -\/ Set/\-Get the Operation to perform.  
\item {\ttfamily obj.\-Set\-Operation\-To\-And ()} -\/ Set/\-Get the Operation to perform.  
\item {\ttfamily obj.\-Set\-Operation\-To\-Or ()} -\/ Set/\-Get the Operation to perform.  
\item {\ttfamily obj.\-Set\-Operation\-To\-Xor ()} -\/ Set/\-Get the Operation to perform.  
\item {\ttfamily obj.\-Set\-Operation\-To\-Nand ()} -\/ Set/\-Get the Operation to perform.  
\item {\ttfamily obj.\-Set\-Operation\-To\-Nor ()} -\/ Set/\-Get the Operation to perform.  
\item {\ttfamily obj.\-Set\-Operation\-To\-Not ()} -\/ Set/\-Get the Operation to perform.  
\item {\ttfamily obj.\-Set\-Output\-True\-Value (double )} -\/ Set the value to use for true in the output.  
\item {\ttfamily double = obj.\-Get\-Output\-True\-Value ()} -\/ Set the value to use for true in the output.  
\item {\ttfamily obj.\-Set\-Input1 (vtk\-Data\-Object input)} -\/ Set the Input1 of this filter.  
\item {\ttfamily obj.\-Set\-Input2 (vtk\-Data\-Object input)} -\/ Set the Input2 of this filter.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageluminance}{}\section{vtk\-Image\-Luminance}\label{vtkimaging_vtkimageluminance}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Luminance calculates luminance from an rgb input.

To create an instance of class vtk\-Image\-Luminance, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageLuminance
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Luminance has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Luminance class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Luminance = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Luminance = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagemagnify}{}\section{vtk\-Image\-Magnify}\label{vtkimaging_vtkimagemagnify}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Magnify maps each pixel of the input onto a nxmx... region of the output. Location (0,0,...) remains in the same place. The magnification occurs via pixel replication, or if Interpolate is on, by bilinear interpolation. Initially, interpolation is off and magnification factors are set to 1 in all directions.

To create an instance of class vtk\-Image\-Magnify, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageMagnify
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Magnify has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Magnify class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Magnify = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Magnify = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Magnification\-Factors (int , int , int )} -\/ Set/\-Get the integer magnification factors in the i-\/j-\/k directions. Initially, factors are set to 1 in all directions.  
\item {\ttfamily obj.\-Set\-Magnification\-Factors (int a\mbox{[}3\mbox{]})} -\/ Set/\-Get the integer magnification factors in the i-\/j-\/k directions. Initially, factors are set to 1 in all directions.  
\item {\ttfamily int = obj. Get\-Magnification\-Factors ()} -\/ Set/\-Get the integer magnification factors in the i-\/j-\/k directions. Initially, factors are set to 1 in all directions.  
\item {\ttfamily obj.\-Set\-Interpolate (int )} -\/ Turn interpolation on and off (pixel replication is used when off). Initially, interpolation is off.  
\item {\ttfamily int = obj.\-Get\-Interpolate ()} -\/ Turn interpolation on and off (pixel replication is used when off). Initially, interpolation is off.  
\item {\ttfamily obj.\-Interpolate\-On ()} -\/ Turn interpolation on and off (pixel replication is used when off). Initially, interpolation is off.  
\item {\ttfamily obj.\-Interpolate\-Off ()} -\/ Turn interpolation on and off (pixel replication is used when off). Initially, interpolation is off.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagemagnitude}{}\section{vtk\-Image\-Magnitude}\label{vtkimaging_vtkimagemagnitude}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Magnitude takes the magnitude of the components.

To create an instance of class vtk\-Image\-Magnitude, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageMagnitude
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Magnitude has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Magnitude class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Magnitude = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Magnitude = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagemandelbrotsource}{}\section{vtk\-Image\-Mandelbrot\-Source}\label{vtkimaging_vtkimagemandelbrotsource}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Mandelbrot\-Source creates an unsigned char image of the Mandelbrot set. The values in the image are the number of iterations it takes for the magnitude of the value to get over 2. The equation repeated is z = z$^\wedge$2 + C (z and C are complex). Initial value of z is zero, and the real value of C is mapped onto the x axis, and the imaginary value of C is mapped onto the Y Axis. I was thinking of extending this source to generate Julia Sets (initial value of Z varies). This would be 4 possible parameters to vary, but there are no more 4d images \-:( The third dimension (z axis) is the imaginary value of the initial value.

To create an instance of class vtk\-Image\-Mandelbrot\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageMandelbrotSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Mandelbrot\-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\-Image\-Mandelbrot\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Mandelbrot\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Mandelbrot\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Whole\-Extent (int extent\mbox{[}6\mbox{]})} -\/ Set/\-Get the extent of the whole output Volume.  
\item {\ttfamily obj.\-Set\-Whole\-Extent (int min\-X, int max\-X, int min\-Y, int max\-Y, int min\-Z, int max\-Z)} -\/ Set/\-Get the extent of the whole output Volume.  
\item {\ttfamily int = obj. Get\-Whole\-Extent ()} -\/ Set/\-Get the extent of the whole output Volume.  
\item {\ttfamily obj.\-Set\-Constant\-Size (int )} -\/ This flag determines whether the Size or spacing of a data set remain constant (when extent is changed). By default, size remains constant.  
\item {\ttfamily int = obj.\-Get\-Constant\-Size ()} -\/ This flag determines whether the Size or spacing of a data set remain constant (when extent is changed). By default, size remains constant.  
\item {\ttfamily obj.\-Constant\-Size\-On ()} -\/ This flag determines whether the Size or spacing of a data set remain constant (when extent is changed). By default, size remains constant.  
\item {\ttfamily obj.\-Constant\-Size\-Off ()} -\/ This flag determines whether the Size or spacing of a data set remain constant (when extent is changed). By default, size remains constant.  
\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). void Set\-Origin\-C\-X(double c\-Real, double c\-Imag, double x\-Real, double x\-Imag);  
\item {\ttfamily obj.\-Set\-Sample\-C\-X (double , double , double , double )} -\/ Imaginary and real value for C (constant in equation) and X (initial value).  
\item {\ttfamily obj.\-Set\-Sample\-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\-Sample\-C\-X ()} -\/ Imaginary and real value for C (constant in equation) and X (initial value). void Set\-Origin\-C\-X(double c\-Real, double c\-Imag, double x\-Real, double x\-Imag);  
\item {\ttfamily obj.\-Set\-Size\-C\-X (double c\-Real, double c\-Imag, double x\-Real, double x\-Imag)} -\/ 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.\-Get\-Size\-C\-X (double s\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 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 short = obj.\-Get\-Maximum\-Number\-Of\-Iterations ()} -\/ The maximum number of cycles run to see if the value goes over 2  
\item {\ttfamily obj.\-Zoom (double factor)} -\/ Convienence for Viewer. Pan 3\-D volume relative to spacing. Zoom constant factor.  
\item {\ttfamily obj.\-Pan (double x, double y, double z)} -\/ Convienence for Viewer. Pan 3\-D volume relative to spacing. Zoom constant factor.  
\item {\ttfamily obj.\-Copy\-Origin\-And\-Sample (vtk\-Image\-Mandelbrot\-Source source)} -\/ Convienence for Viewer. Copy the Origin\-C\-X and the Spacing\-C\-X. What about other parameters ???  
\item {\ttfamily obj.\-Set\-Subsample\-Rate (int )} -\/ Set/\-Get a subsample rate.  
\item {\ttfamily int = obj.\-Get\-Subsample\-Rate\-Min\-Value ()} -\/ Set/\-Get a subsample rate.  
\item {\ttfamily int = obj.\-Get\-Subsample\-Rate\-Max\-Value ()} -\/ Set/\-Get a subsample rate.  
\item {\ttfamily int = obj.\-Get\-Subsample\-Rate ()} -\/ Set/\-Get a subsample rate.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagemaptocolors}{}\section{vtk\-Image\-Map\-To\-Colors}\label{vtkimaging_vtkimagemaptocolors}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Image\-Map\-To\-Colors filter will take an input image of any valid scalar type, and map the first component of the image through a lookup table. The result is an image of type V\-T\-K\-\_\-\-U\-N\-S\-I\-G\-N\-E\-D\-\_\-\-C\-H\-A\-R. If the lookup table is not set, or is set to N\-U\-L\-L, then the input data will be passed through if it is already of type V\-T\-K\-\_\-\-U\-N\-S\-I\-G\-N\-E\-D\-\_\-\-C\-H\-A\-R.

To create an instance of class vtk\-Image\-Map\-To\-Colors, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageMapToColors
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Map\-To\-Colors has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Image\-Map\-To\-Colors class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Map\-To\-Colors = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Map\-To\-Colors = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Lookup\-Table (vtk\-Scalars\-To\-Colors )} -\/ Set the lookup table.  
\item {\ttfamily vtk\-Scalars\-To\-Colors = obj.\-Get\-Lookup\-Table ()} -\/ Set the lookup table.  
\item {\ttfamily obj.\-Set\-Output\-Format (int )} -\/ Set the output format, the default is R\-G\-B\-A.  
\item {\ttfamily int = obj.\-Get\-Output\-Format ()} -\/ Set the output format, the default is R\-G\-B\-A.  
\item {\ttfamily obj.\-Set\-Output\-Format\-To\-R\-G\-B\-A ()} -\/ Set the output format, the default is R\-G\-B\-A.  
\item {\ttfamily obj.\-Set\-Output\-Format\-To\-R\-G\-B ()} -\/ Set the output format, the default is R\-G\-B\-A.  
\item {\ttfamily obj.\-Set\-Output\-Format\-To\-Luminance\-Alpha ()} -\/ Set the output format, the default is R\-G\-B\-A.  
\item {\ttfamily obj.\-Set\-Output\-Format\-To\-Luminance ()} -\/ Set the output format, the default is R\-G\-B\-A.  
\item {\ttfamily obj.\-Set\-Active\-Component (int )} -\/ Set the component to map for multi-\/component images (default\-: 0)  
\item {\ttfamily int = obj.\-Get\-Active\-Component ()} -\/ Set the component to map for multi-\/component images (default\-: 0)  
\item {\ttfamily obj.\-Set\-Pass\-Alpha\-To\-Output (int )} -\/ Use the alpha component of the input when computing the alpha component of the output (useful when converting monochrome+alpha data to R\-G\-B\-A)  
\item {\ttfamily obj.\-Pass\-Alpha\-To\-Output\-On ()} -\/ Use the alpha component of the input when computing the alpha component of the output (useful when converting monochrome+alpha data to R\-G\-B\-A)  
\item {\ttfamily obj.\-Pass\-Alpha\-To\-Output\-Off ()} -\/ Use the alpha component of the input when computing the alpha component of the output (useful when converting monochrome+alpha data to R\-G\-B\-A)  
\item {\ttfamily int = obj.\-Get\-Pass\-Alpha\-To\-Output ()} -\/ Use the alpha component of the input when computing the alpha component of the output (useful when converting monochrome+alpha data to R\-G\-B\-A)  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ We need to check the modified time of the lookup table too.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagemaptorgba}{}\section{vtk\-Image\-Map\-To\-R\-G\-B\-A}\label{vtkimaging_vtkimagemaptorgba}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This filter has been replaced by vtk\-Image\-Map\-To\-Colors, which provided additional features. Use vtk\-Image\-Map\-To\-Colors instead.

To create an instance of class vtk\-Image\-Map\-To\-R\-G\-B\-A, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageMapToRGBA
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Map\-To\-R\-G\-B\-A has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Map\-To\-R\-G\-B\-A class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Map\-To\-R\-G\-B\-A = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Map\-To\-R\-G\-B\-A = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagemaptowindowlevelcolors}{}\section{vtk\-Image\-Map\-To\-Window\-Level\-Colors}\label{vtkimaging_vtkimagemaptowindowlevelcolors}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Image\-Map\-To\-Window\-Level\-Colors filter will take an input image of any valid scalar type, and map the first component of the image through a lookup table. This resulting color will be modulated with value obtained by a window / level operation. The result is an image of type V\-T\-K\-\_\-\-U\-N\-S\-I\-G\-N\-E\-D\-\_\-\-C\-H\-A\-R. If the lookup table is not set, or is set to N\-U\-L\-L, then the input data will be passed through if it is already of type U\-N\-S\-I\-G\-N\-E\-D\-\_\-\-C\-H\-A\-R.

To create an instance of class vtk\-Image\-Map\-To\-Window\-Level\-Colors, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageMapToWindowLevelColors
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Map\-To\-Window\-Level\-Colors has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Image\-Map\-To\-Window\-Level\-Colors class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Map\-To\-Window\-Level\-Colors = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Map\-To\-Window\-Level\-Colors = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Window (double )} -\/ Set / Get the Window to use -\/$>$ modulation will be performed on the color based on (S -\/ (L -\/ W/2))/\-W where S is the scalar value, L is the level and W is the window.  
\item {\ttfamily double = obj.\-Get\-Window ()} -\/ Set / Get the Window to use -\/$>$ modulation will be performed on the color based on (S -\/ (L -\/ W/2))/\-W where S is the scalar value, L is the level and W is the window.  
\item {\ttfamily obj.\-Set\-Level (double )} -\/ Set / Get the Level to use -\/$>$ modulation will be performed on the color based on (S -\/ (L -\/ W/2))/\-W where S is the scalar value, L is the level and W is the window.  
\item {\ttfamily double = obj.\-Get\-Level ()} -\/ Set / Get the Level to use -\/$>$ modulation will be performed on the color based on (S -\/ (L -\/ W/2))/\-W where S is the scalar value, L is the level and W is the window.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagemask}{}\section{vtk\-Image\-Mask}\label{vtkimaging_vtkimagemask}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Mask combines a mask with an image. Non zero mask implies the output pixel will be the same as the image. If a mask pixel is zero, then the output pixel is set to \char`\"{}\-Masked\-Value\char`\"{}. The filter also has the option to pass the mask through a boolean not operation before processing the image. This reverses the passed and replaced pixels. The two inputs should have the same \char`\"{}\-Whole\-Extent\char`\"{}. The mask input should be unsigned char, and the image scalar type is the same as the output scalar type.

To create an instance of class vtk\-Image\-Mask, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageMask
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Mask has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Mask class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Mask = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Mask = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Masked\-Output\-Value (int num, double v)} -\/ Set\-Get the value of the output pixel replaced by mask.  
\item {\ttfamily obj.\-Set\-Masked\-Output\-Value (double v)} -\/ Set\-Get the value of the output pixel replaced by mask.  
\item {\ttfamily obj.\-Set\-Masked\-Output\-Value (double v1, double v2)} -\/ Set\-Get the value of the output pixel replaced by mask.  
\item {\ttfamily obj.\-Set\-Masked\-Output\-Value (double v1, double v2, double v3)} -\/ Set\-Get the value of the output pixel replaced by mask.  
\item {\ttfamily int = obj.\-Get\-Masked\-Output\-Value\-Length ()} -\/ Set/\-Get the alpha blending value for the mask The input image is assumed to be at alpha = 1.\-0 and the mask image uses this alpha to blend using an over operator.  
\item {\ttfamily obj.\-Set\-Mask\-Alpha (double )} -\/ Set/\-Get the alpha blending value for the mask The input image is assumed to be at alpha = 1.\-0 and the mask image uses this alpha to blend using an over operator.  
\item {\ttfamily double = obj.\-Get\-Mask\-Alpha\-Min\-Value ()} -\/ Set/\-Get the alpha blending value for the mask The input image is assumed to be at alpha = 1.\-0 and the mask image uses this alpha to blend using an over operator.  
\item {\ttfamily double = obj.\-Get\-Mask\-Alpha\-Max\-Value ()} -\/ Set/\-Get the alpha blending value for the mask The input image is assumed to be at alpha = 1.\-0 and the mask image uses this alpha to blend using an over operator.  
\item {\ttfamily double = obj.\-Get\-Mask\-Alpha ()} -\/ Set/\-Get the alpha blending value for the mask The input image is assumed to be at alpha = 1.\-0 and the mask image uses this alpha to blend using an over operator.  
\item {\ttfamily obj.\-Set\-Image\-Input (vtk\-Image\-Data in)} -\/ Set the input to be masked.  
\item {\ttfamily obj.\-Set\-Mask\-Input (vtk\-Image\-Data in)} -\/ Set the mask to be used.  
\item {\ttfamily obj.\-Set\-Not\-Mask (int )} -\/ When Not Mask is on, the mask is passed through a boolean not before it is used to mask the image. The effect is to pass the pixels where the input mask is zero, and replace the pixels where the input value is non zero.  
\item {\ttfamily int = obj.\-Get\-Not\-Mask ()} -\/ When Not Mask is on, the mask is passed through a boolean not before it is used to mask the image. The effect is to pass the pixels where the input mask is zero, and replace the pixels where the input value is non zero.  
\item {\ttfamily obj.\-Not\-Mask\-On ()} -\/ When Not Mask is on, the mask is passed through a boolean not before it is used to mask the image. The effect is to pass the pixels where the input mask is zero, and replace the pixels where the input value is non zero.  
\item {\ttfamily obj.\-Not\-Mask\-Off ()} -\/ When Not Mask is on, the mask is passed through a boolean not before it is used to mask the image. The effect is to pass the pixels where the input mask is zero, and replace the pixels where the input value is non zero.  
\item {\ttfamily obj.\-Set\-Input1 (vtk\-Data\-Object in)} -\/ Set the two inputs to this filter  
\item {\ttfamily obj.\-Set\-Input2 (vtk\-Data\-Object in)}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagemaskbits}{}\section{vtk\-Image\-Mask\-Bits}\label{vtkimaging_vtkimagemaskbits}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Mask\-Bits applies a bit-\/mask pattern to each component. The bit-\/mask can be applied using a variety of boolean bitwise operators.

To create an instance of class vtk\-Image\-Mask\-Bits, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageMaskBits
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Mask\-Bits has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Mask\-Bits class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Mask\-Bits = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Mask\-Bits = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Masks (int , int , int , int )} -\/ Set/\-Get the bit-\/masks. Default is 0xffffffff.  
\item {\ttfamily obj.\-Set\-Masks (int a\mbox{[}4\mbox{]})} -\/ Set/\-Get the bit-\/masks. Default is 0xffffffff.  
\item {\ttfamily obj.\-Set\-Mask (int mask)} -\/ Set/\-Get the bit-\/masks. Default is 0xffffffff.  
\item {\ttfamily obj.\-Set\-Masks (int mask1, int mask2)} -\/ Set/\-Get the bit-\/masks. Default is 0xffffffff.  
\item {\ttfamily obj.\-Set\-Masks (int mask1, int mask2, int mask3)} -\/ Set/\-Get the bit-\/masks. Default is 0xffffffff.  
\item {\ttfamily int = obj. Get\-Masks ()} -\/ Set/\-Get the bit-\/masks. Default is 0xffffffff.  
\item {\ttfamily obj.\-Set\-Operation (int )} -\/ Set/\-Get the boolean operator. Default is A\-N\-D.  
\item {\ttfamily int = obj.\-Get\-Operation ()} -\/ Set/\-Get the boolean operator. Default is A\-N\-D.  
\item {\ttfamily obj.\-Set\-Operation\-To\-And ()} -\/ Set/\-Get the boolean operator. Default is A\-N\-D.  
\item {\ttfamily obj.\-Set\-Operation\-To\-Or ()} -\/ Set/\-Get the boolean operator. Default is A\-N\-D.  
\item {\ttfamily obj.\-Set\-Operation\-To\-Xor ()} -\/ Set/\-Get the boolean operator. Default is A\-N\-D.  
\item {\ttfamily obj.\-Set\-Operation\-To\-Nand ()} -\/ Set/\-Get the boolean operator. Default is A\-N\-D.  
\item {\ttfamily obj.\-Set\-Operation\-To\-Nor ()} -\/ Set/\-Get the boolean operator. Default is A\-N\-D.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagemathematics}{}\section{vtk\-Image\-Mathematics}\label{vtkimaging_vtkimagemathematics}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Mathematics implements basic mathematic operations Set\-Operation is used to select the filters behavior. The filter can take two or one input.

To create an instance of class vtk\-Image\-Mathematics, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageMathematics
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Mathematics has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Mathematics class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Mathematics = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Mathematics = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Operation (int )} -\/ Set/\-Get the Operation to perform.  
\item {\ttfamily int = obj.\-Get\-Operation ()} -\/ Set/\-Get the Operation to perform.  
\item {\ttfamily obj.\-Set\-Operation\-To\-Add ()} -\/ Set each pixel in the output image to the sum of the corresponding pixels in Input1 and Input2.  
\item {\ttfamily obj.\-Set\-Operation\-To\-Subtract ()} -\/ Set each pixel in the output image to the difference of the corresponding pixels in Input1 and Input2 (output = Input1 -\/ Input2).  
\item {\ttfamily obj.\-Set\-Operation\-To\-Multiply ()} -\/ Set each pixel in the output image to the product of the corresponding pixels in Input1 and Input2.  
\item {\ttfamily obj.\-Set\-Operation\-To\-Divide ()} -\/ Set each pixel in the output image to the quotient of the corresponding pixels in Input1 and Input2 (Output = Input1 / Input2).  
\item {\ttfamily obj.\-Set\-Operation\-To\-Conjugate ()}  
\item {\ttfamily obj.\-Set\-Operation\-To\-Complex\-Multiply ()}  
\item {\ttfamily obj.\-Set\-Operation\-To\-Invert ()} -\/ Set each pixel in the output image to 1 over the corresponding pixel in Input1 and Input2 (output = 1 / Input1). Input2 is not used.  
\item {\ttfamily obj.\-Set\-Operation\-To\-Sin ()} -\/ Set each pixel in the output image to the sine of the corresponding pixel in Input1. Input2 is not used.  
\item {\ttfamily obj.\-Set\-Operation\-To\-Cos ()} -\/ Set each pixel in the output image to the cosine of the corresponding pixel in Input1. Input2 is not used.  
\item {\ttfamily obj.\-Set\-Operation\-To\-Exp ()} -\/ Set each pixel in the output image to the exponential of the corresponding pixel in Input1. Input2 is not used.  
\item {\ttfamily obj.\-Set\-Operation\-To\-Log ()} -\/ Set each pixel in the output image to the log of the corresponding pixel in Input1. Input2 is not used.  
\item {\ttfamily obj.\-Set\-Operation\-To\-Absolute\-Value ()} -\/ Set each pixel in the output image to the absolute value of the corresponding pixel in Input1. Input2 is not used.  
\item {\ttfamily obj.\-Set\-Operation\-To\-Square ()} -\/ Set each pixel in the output image to the square of the corresponding pixel in Input1. Input2 is not used.  
\item {\ttfamily obj.\-Set\-Operation\-To\-Square\-Root ()} -\/ Set each pixel in the output image to the square root of the corresponding pixel in Input1. Input2 is not used.  
\item {\ttfamily obj.\-Set\-Operation\-To\-Min ()} -\/ Set each pixel in the output image to the minimum of the corresponding pixels in Input1 and Input2. (Output = min(\-Input1, Input2))  
\item {\ttfamily obj.\-Set\-Operation\-To\-Max ()} -\/ Set each pixel in the output image to the maximum of the corresponding pixels in Input1 and Input2. (Output = max(\-Input1, Input2))  
\item {\ttfamily obj.\-Set\-Operation\-To\-A\-T\-A\-N ()} -\/ Set each pixel in the output image to the arctangent of the corresponding pixel in Input1. Input2 is not used.  
\item {\ttfamily obj.\-Set\-Operation\-To\-A\-T\-A\-N2 ()}  
\item {\ttfamily obj.\-Set\-Operation\-To\-Multiply\-By\-K ()} -\/ Set each pixel in the output image to the product of Constant\-K with the corresponding pixel in Input1. Input2 is not used.  
\item {\ttfamily obj.\-Set\-Operation\-To\-Add\-Constant ()} -\/ Set each pixel in the output image to the product of Constant\-C with the corresponding pixel in Input1. Input2 is not used.  
\item {\ttfamily obj.\-Set\-Operation\-To\-Replace\-C\-By\-K ()} -\/ Find every pixel in Input1 that equals Constant\-C and set the corresponding pixels in the Output to Constant\-K. Input2 is not used.  
\item {\ttfamily obj.\-Set\-Constant\-K (double )} -\/ A constant used by some operations (typically multiplicative). Default is 1.  
\item {\ttfamily double = obj.\-Get\-Constant\-K ()} -\/ A constant used by some operations (typically multiplicative). Default is 1.  
\item {\ttfamily obj.\-Set\-Constant\-C (double )} -\/ A constant used by some operations (typically additive). Default is 0.  
\item {\ttfamily double = obj.\-Get\-Constant\-C ()} -\/ A constant used by some operations (typically additive). Default is 0.  
\item {\ttfamily obj.\-Set\-Divide\-By\-Zero\-To\-C (int )} -\/ How to handle divide by zero. Default is 0.  
\item {\ttfamily int = obj.\-Get\-Divide\-By\-Zero\-To\-C ()} -\/ How to handle divide by zero. Default is 0.  
\item {\ttfamily obj.\-Divide\-By\-Zero\-To\-C\-On ()} -\/ How to handle divide by zero. Default is 0.  
\item {\ttfamily obj.\-Divide\-By\-Zero\-To\-C\-Off ()} -\/ How to handle divide by zero. Default is 0.  
\item {\ttfamily obj.\-Set\-Input1 (vtk\-Data\-Object in)} -\/ Set the two inputs to this filter. For some operations, the second input is not used.  
\item {\ttfamily obj.\-Set\-Input2 (vtk\-Data\-Object in)}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagemedian3d}{}\section{vtk\-Image\-Median3\-D}\label{vtkimaging_vtkimagemedian3d}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Median3\-D a Median filter that replaces each pixel with the median value from a rectangular neighborhood around that pixel. Neighborhoods can be no more than 3 dimensional. Setting one axis of the neighborhood kernel\-Size to 1 changes the filter into a 2\-D median.

To create an instance of class vtk\-Image\-Median3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageMedian3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Median3\-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\-Image\-Median3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Median3\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Median3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Kernel\-Size (int size0, int size1, int size2)} -\/ This method sets the size of the neighborhood. It also sets the default middle of the neighborhood  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Elements ()} -\/ Return the number of elements in the median mask  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagemirrorpad}{}\section{vtk\-Image\-Mirror\-Pad}\label{vtkimaging_vtkimagemirrorpad}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Mirror\-Pad makes an image larger by filling extra pixels with a mirror image of the original image (mirror at image boundaries).

To create an instance of class vtk\-Image\-Mirror\-Pad, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageMirrorPad
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Mirror\-Pad has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Mirror\-Pad class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Mirror\-Pad = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Mirror\-Pad = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagenoisesource}{}\section{vtk\-Image\-Noise\-Source}\label{vtkimaging_vtkimagenoisesource}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Noise\-Source just produces images filled with noise. The only option now is uniform noise specified by a min and a max. There is one major problem with this source. Every time it executes, it will output different pixel values. This has important implications when a stream requests overlapping regions. The same pixels will have different values on different updates.

To create an instance of class vtk\-Image\-Noise\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageNoiseSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Noise\-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\-Image\-Noise\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Noise\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Noise\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Minimum (double )} -\/ Set/\-Get the minimum and maximum values for the generated noise.  
\item {\ttfamily double = obj.\-Get\-Minimum ()} -\/ Set/\-Get the minimum and maximum values for the generated noise.  
\item {\ttfamily obj.\-Set\-Maximum (double )} -\/ Set/\-Get the minimum and maximum values for the generated noise.  
\item {\ttfamily double = obj.\-Get\-Maximum ()} -\/ Set/\-Get the minimum and maximum values for the generated noise.  
\item {\ttfamily obj.\-Set\-Whole\-Extent (int x\-Minx, int x\-Max, int y\-Min, int y\-Max, int z\-Min, int z\-Max)} -\/ Set how large of an image to generate.  
\item {\ttfamily obj.\-Set\-Whole\-Extent (int ext\mbox{[}6\mbox{]})}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagenonmaximumsuppression}{}\section{vtk\-Image\-Non\-Maximum\-Suppression}\label{vtkimaging_vtkimagenonmaximumsuppression}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Non\-Maximum\-Suppression Sets to zero any pixel that is not a peak. If a pixel has a neighbor along the vector that has larger magnitude, the smaller pixel is set to zero. The filter takes two inputs\-: a magnitude and a vector. Output is magnitude information and is always in doubles. Typically this filter is used with vtk\-Image\-Gradient and vtk\-Image\-Gradient\-Magnitude as inputs.

To create an instance of class vtk\-Image\-Non\-Maximum\-Suppression, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageNonMaximumSuppression
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Non\-Maximum\-Suppression has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Non\-Maximum\-Suppression class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Non\-Maximum\-Suppression = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Non\-Maximum\-Suppression = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Magnitude\-Input (vtk\-Image\-Data input)} -\/ Set the magnitude and vector inputs.  
\item {\ttfamily obj.\-Set\-Vector\-Input (vtk\-Image\-Data input)} -\/ Set the magnitude and vector inputs.  
\item {\ttfamily obj.\-Set\-Handle\-Boundaries (int )} -\/ If \char`\"{}\-Handle\-Boundaries\-On\char`\"{} then boundary pixels are duplicated So central differences can get values.  
\item {\ttfamily int = obj.\-Get\-Handle\-Boundaries ()} -\/ If \char`\"{}\-Handle\-Boundaries\-On\char`\"{} then boundary pixels are duplicated So central differences can get values.  
\item {\ttfamily obj.\-Handle\-Boundaries\-On ()} -\/ If \char`\"{}\-Handle\-Boundaries\-On\char`\"{} then boundary pixels are duplicated So central differences can get values.  
\item {\ttfamily obj.\-Handle\-Boundaries\-Off ()} -\/ If \char`\"{}\-Handle\-Boundaries\-On\char`\"{} then boundary pixels are duplicated So central differences can get values.  
\item {\ttfamily obj.\-Set\-Dimensionality (int )} -\/ Determines how the input is interpreted (set of 2d slices or a 3\-D volume)  
\item {\ttfamily int = obj.\-Get\-Dimensionality\-Min\-Value ()} -\/ Determines how the input is interpreted (set of 2d slices or a 3\-D volume)  
\item {\ttfamily int = obj.\-Get\-Dimensionality\-Max\-Value ()} -\/ Determines how the input is interpreted (set of 2d slices or a 3\-D volume)  
\item {\ttfamily int = obj.\-Get\-Dimensionality ()} -\/ Determines how the input is interpreted (set of 2d slices or a 3\-D volume)  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagenormalize}{}\section{vtk\-Image\-Normalize}\label{vtkimaging_vtkimagenormalize}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
For each point, vtk\-Image\-Normalize normalizes the vector defined by the scalar components. If the magnitude of this vector is zero, the output vector is zero also.

To create an instance of class vtk\-Image\-Normalize, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageNormalize
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Normalize has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Normalize class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Normalize = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Normalize = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageopenclose3d}{}\section{vtk\-Image\-Open\-Close3\-D}\label{vtkimaging_vtkimageopenclose3d}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Open\-Close3\-D performs opening or closing by having two vtk\-Image\-Erode\-Dilates in series. The size of operation is determined by the method Set\-Kernel\-Size, and the operator is an ellipse. Open\-Value and Close\-Value determine how the filter behaves. For binary images Opening and closing behaves as expected. Close value is first dilated, and then eroded. Open value is first eroded, and then dilated. Degenerate two dimensional opening/closing can be achieved by setting the one axis the 3\-D Kernel\-Size to 1. Values other than open value and close value are not touched. This enables the filter to processes segmented images containing more than two tags.

To create an instance of class vtk\-Image\-Open\-Close3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageOpenClose3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Open\-Close3\-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\-Image\-Open\-Close3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Default open value is 0, and default close value is 255.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Default open value is 0, and default close value is 255.  
\item {\ttfamily vtk\-Image\-Open\-Close3\-D = obj.\-New\-Instance ()} -\/ Default open value is 0, and default close value is 255.  
\item {\ttfamily vtk\-Image\-Open\-Close3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Default open value is 0, and default close value is 255.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ This method considers the sub filters M\-Times when computing this objects modified time.  
\item {\ttfamily obj.\-Debug\-On ()} -\/ Turn debugging output on. (in sub filters also)  
\item {\ttfamily obj.\-Debug\-Off ()} -\/ Turn debugging output on. (in sub filters also)  
\item {\ttfamily obj.\-Modified ()} -\/ Pass modified message to sub filters.  
\item {\ttfamily obj.\-Set\-Kernel\-Size (int size0, int size1, int size2)} -\/ Selects the size of gaps or objects removed.  
\item {\ttfamily obj.\-Set\-Open\-Value (double value)} -\/ Determines the value that will opened. Open value is first eroded, and then dilated.  
\item {\ttfamily double = obj.\-Get\-Open\-Value ()} -\/ Determines the value that will opened. Open value is first eroded, and then dilated.  
\item {\ttfamily obj.\-Set\-Close\-Value (double value)} -\/ Determines the value that will closed. Close value is first dilated, and then eroded  
\item {\ttfamily double = obj.\-Get\-Close\-Value ()} -\/ Determines the value that will closed. Close value is first dilated, and then eroded  
\item {\ttfamily vtk\-Image\-Dilate\-Erode3\-D = obj.\-Get\-Filter0 ()} -\/ Needed for Progress functions  
\item {\ttfamily vtk\-Image\-Dilate\-Erode3\-D = obj.\-Get\-Filter1 ()} -\/ Needed for Progress functions  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagepadfilter}{}\section{vtk\-Image\-Pad\-Filter}\label{vtkimaging_vtkimagepadfilter}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Pad\-Filter Changes the image extent of an image. If the image extent is larger than the input image extent, the extra pixels are filled by an algorithm determined by the subclass. The image extent of the output has to be specified.

To create an instance of class vtk\-Image\-Pad\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImagePadFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Pad\-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\-Pad\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Pad\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Pad\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Output\-Whole\-Extent (int extent\mbox{[}6\mbox{]})} -\/ The image 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 image extent of the output has to be set explicitly.  
\item {\ttfamily obj.\-Get\-Output\-Whole\-Extent (int extent\mbox{[}6\mbox{]})} -\/ The image extent of the output has to be set explicitly.  
\item {\ttfamily int = obj.\-Get\-Output\-Whole\-Extent ()} -\/ Set/\-Get the number of output scalar components.  
\item {\ttfamily obj.\-Set\-Output\-Number\-Of\-Scalar\-Components (int )} -\/ Set/\-Get the number of output scalar components.  
\item {\ttfamily int = obj.\-Get\-Output\-Number\-Of\-Scalar\-Components ()} -\/ Set/\-Get the number of output scalar components.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagepermute}{}\section{vtk\-Image\-Permute}\label{vtkimaging_vtkimagepermute}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Permute reorders the axes of the input. Filtered axes specify the input axes which become X, Y, Z. The input has to have the same scalar type of the output. The filter does copy the data when it executes. This filter is actually a very thin wrapper around vtk\-Image\-Reslice.

To create an instance of class vtk\-Image\-Permute, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImagePermute
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Permute has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Permute class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Permute = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Permute = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Filtered\-Axes (int x, int y, int z)} -\/ The filtered axes are the input axes that get relabeled to X,Y,Z.  
\item {\ttfamily obj.\-Set\-Filtered\-Axes (int xyz\mbox{[}3\mbox{]})} -\/ The filtered axes are the input axes that get relabeled to X,Y,Z.  
\item {\ttfamily int = obj. Get\-Filtered\-Axes ()} -\/ The filtered axes are the input axes that get relabeled to X,Y,Z.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagequantizergbtoindex}{}\section{vtk\-Image\-Quantize\-R\-G\-B\-To\-Index}\label{vtkimaging_vtkimagequantizergbtoindex}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Quantize\-R\-G\-B\-To\-Index takes a 3 component R\-G\-B image as input and produces a one component index image as output, along with a lookup table that contains the color definitions for the index values. This filter works on the entire input extent -\/ it does not perform streaming, and it does not supported threaded execution (because it has to process the entire image).

To use this filter, you typically set the number of colors (between 2 and 65536), execute it, and then retrieve the lookup table. The colors can then be using the lookup table and the image index.

To create an instance of class vtk\-Image\-Quantize\-R\-G\-B\-To\-Index, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageQuantizeRGBToIndex
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Quantize\-R\-G\-B\-To\-Index has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Quantize\-R\-G\-B\-To\-Index class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Quantize\-R\-G\-B\-To\-Index = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Quantize\-R\-G\-B\-To\-Index = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Number\-Of\-Colors (int )} -\/ Set / Get the number of color index values to produce -\/ must be a number between 2 and 65536.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Colors\-Min\-Value ()} -\/ Set / Get the number of color index values to produce -\/ must be a number between 2 and 65536.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Colors\-Max\-Value ()} -\/ Set / Get the number of color index values to produce -\/ must be a number between 2 and 65536.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Colors ()} -\/ Set / Get the number of color index values to produce -\/ must be a number between 2 and 65536.  
\item {\ttfamily vtk\-Lookup\-Table = obj.\-Get\-Lookup\-Table ()} -\/ Get the resulting lookup table that contains the color definitions corresponding to the index values in the output image.  
\item {\ttfamily double = obj.\-Get\-Initialize\-Execute\-Time ()}  
\item {\ttfamily double = obj.\-Get\-Build\-Tree\-Execute\-Time ()}  
\item {\ttfamily double = obj.\-Get\-Lookup\-Index\-Execute\-Time ()}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagerange3d}{}\section{vtk\-Image\-Range3\-D}\label{vtkimaging_vtkimagerange3d}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Range3\-D replaces a pixel with the maximum minus minimum over an ellipsoidal neighborhood. If Kernel\-Size of an axis is 1, no processing is done on that axis.

To create an instance of class vtk\-Image\-Range3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageRange3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Range3\-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\-Image\-Range3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Range3\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Range3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Kernel\-Size (int size0, int size1, int size2)} -\/ This method sets the size of the neighborhood. It also sets the default middle of the neighborhood and computes the elliptical foot print.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagerectilinearwipe}{}\section{vtk\-Image\-Rectilinear\-Wipe}\label{vtkimaging_vtkimagerectilinearwipe}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Rectilinear\-Wipe makes a rectilinear combination of two images. The two input images must correspond in size, scalar type and number of components. The resulting image has four possible configurations called\-: Quad -\/ alternate input 0 and input 1 horizontally and vertically. Select this with Set\-Wipe\-Mode\-To\-Quad. The Position specifies the location of the quad intersection. Corner -\/ 3 of one input and 1 of the other. Select the location of input 0 with with Set\-Wipe\-Mode\-To\-Lower\-Left, Set\-Wipe\-Mode\-To\-Lower\-Right, Set\-Wipe\-Mode\-To\-Upper\-Left and Set\-Wipe\-Mode\-To\-Upper\-Right. The Position selects the location of the corner. Horizontal -\/ alternate input 0 and input 1 with a vertical split. Select this with Set\-Wipe\-Mode\-To\-Horizontal. Position\mbox{[}0\mbox{]} specifies the location of the vertical transition between input 0 and input 1. Vertical -\/ alternate input 0 and input 1 with a horizontal split. Only the y The intersection point of the rectilinear points is controlled with the Point ivar.

To create an instance of class vtk\-Image\-Rectilinear\-Wipe, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageRectilinearWipe
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Rectilinear\-Wipe has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Rectilinear\-Wipe class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Rectilinear\-Wipe = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Rectilinear\-Wipe = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Position (int , int )} -\/ Set/\-Get the location of the image transition. Note that position is specified in pixels.  
\item {\ttfamily obj.\-Set\-Position (int a\mbox{[}2\mbox{]})} -\/ Set/\-Get the location of the image transition. Note that position is specified in pixels.  
\item {\ttfamily int = obj. Get\-Position ()} -\/ Set/\-Get the location of the image transition. Note that position is specified in pixels.  
\item {\ttfamily obj.\-Set\-Input1 (vtk\-Data\-Object in)} -\/ Set the two inputs to this filter.  
\item {\ttfamily obj.\-Set\-Input2 (vtk\-Data\-Object in)} -\/ Specify the wipe mode. This mode determnis how input 0 and input 1 are combined to produce the output. Each mode uses one or both of the values stored in Position. Set\-Wipe\-To\-Quad -\/ alternate input 0 and input 1 horizontally and vertically. The Position specifies the location of the quad intersection. Set\-Wipe\-To\-Lower\-Left\{Lower\-Right,Upper\-Left.\-Upper\-Right\} -\/ 3 of one input and 1 of the other. Select the location of input 0 to the Lower\-Left\{Lower\-Right,Upper\-Left,Upper\-Right\}. Position selects the location of the corner. Set\-Wipe\-To\-Horizontal -\/ alternate input 0 and input 1 with a vertical split. Position\mbox{[}0\mbox{]} specifies the location of the vertical transition between input 0 and input 1. Set\-Wipe\-To\-Vertical -\/ alternate input 0 and input 1 with a horizontal split. Position\mbox{[}1\mbox{]} specifies the location of the horizonal transition between input 0 and input 1.  
\item {\ttfamily obj.\-Set\-Wipe (int )} -\/ Specify the wipe mode. This mode determnis how input 0 and input 1 are combined to produce the output. Each mode uses one or both of the values stored in Position. Set\-Wipe\-To\-Quad -\/ alternate input 0 and input 1 horizontally and vertically. The Position specifies the location of the quad intersection. Set\-Wipe\-To\-Lower\-Left\{Lower\-Right,Upper\-Left.\-Upper\-Right\} -\/ 3 of one input and 1 of the other. Select the location of input 0 to the Lower\-Left\{Lower\-Right,Upper\-Left,Upper\-Right\}. Position selects the location of the corner. Set\-Wipe\-To\-Horizontal -\/ alternate input 0 and input 1 with a vertical split. Position\mbox{[}0\mbox{]} specifies the location of the vertical transition between input 0 and input 1. Set\-Wipe\-To\-Vertical -\/ alternate input 0 and input 1 with a horizontal split. Position\mbox{[}1\mbox{]} specifies the location of the horizonal transition between input 0 and input 1.  
\item {\ttfamily int = obj.\-Get\-Wipe\-Min\-Value ()} -\/ Specify the wipe mode. This mode determnis how input 0 and input 1 are combined to produce the output. Each mode uses one or both of the values stored in Position. Set\-Wipe\-To\-Quad -\/ alternate input 0 and input 1 horizontally and vertically. The Position specifies the location of the quad intersection. Set\-Wipe\-To\-Lower\-Left\{Lower\-Right,Upper\-Left.\-Upper\-Right\} -\/ 3 of one input and 1 of the other. Select the location of input 0 to the Lower\-Left\{Lower\-Right,Upper\-Left,Upper\-Right\}. Position selects the location of the corner. Set\-Wipe\-To\-Horizontal -\/ alternate input 0 and input 1 with a vertical split. Position\mbox{[}0\mbox{]} specifies the location of the vertical transition between input 0 and input 1. Set\-Wipe\-To\-Vertical -\/ alternate input 0 and input 1 with a horizontal split. Position\mbox{[}1\mbox{]} specifies the location of the horizonal transition between input 0 and input 1.  
\item {\ttfamily int = obj.\-Get\-Wipe\-Max\-Value ()} -\/ Specify the wipe mode. This mode determnis how input 0 and input 1 are combined to produce the output. Each mode uses one or both of the values stored in Position. Set\-Wipe\-To\-Quad -\/ alternate input 0 and input 1 horizontally and vertically. The Position specifies the location of the quad intersection. Set\-Wipe\-To\-Lower\-Left\{Lower\-Right,Upper\-Left.\-Upper\-Right\} -\/ 3 of one input and 1 of the other. Select the location of input 0 to the Lower\-Left\{Lower\-Right,Upper\-Left,Upper\-Right\}. Position selects the location of the corner. Set\-Wipe\-To\-Horizontal -\/ alternate input 0 and input 1 with a vertical split. Position\mbox{[}0\mbox{]} specifies the location of the vertical transition between input 0 and input 1. Set\-Wipe\-To\-Vertical -\/ alternate input 0 and input 1 with a horizontal split. Position\mbox{[}1\mbox{]} specifies the location of the horizonal transition between input 0 and input 1.  
\item {\ttfamily int = obj.\-Get\-Wipe ()} -\/ Specify the wipe mode. This mode determnis how input 0 and input 1 are combined to produce the output. Each mode uses one or both of the values stored in Position. Set\-Wipe\-To\-Quad -\/ alternate input 0 and input 1 horizontally and vertically. The Position specifies the location of the quad intersection. Set\-Wipe\-To\-Lower\-Left\{Lower\-Right,Upper\-Left.\-Upper\-Right\} -\/ 3 of one input and 1 of the other. Select the location of input 0 to the Lower\-Left\{Lower\-Right,Upper\-Left,Upper\-Right\}. Position selects the location of the corner. Set\-Wipe\-To\-Horizontal -\/ alternate input 0 and input 1 with a vertical split. Position\mbox{[}0\mbox{]} specifies the location of the vertical transition between input 0 and input 1. Set\-Wipe\-To\-Vertical -\/ alternate input 0 and input 1 with a horizontal split. Position\mbox{[}1\mbox{]} specifies the location of the horizonal transition between input 0 and input 1.  
\item {\ttfamily obj.\-Set\-Wipe\-To\-Quad ()} -\/ Specify the wipe mode. This mode determnis how input 0 and input 1 are combined to produce the output. Each mode uses one or both of the values stored in Position. Set\-Wipe\-To\-Quad -\/ alternate input 0 and input 1 horizontally and vertically. The Position specifies the location of the quad intersection. Set\-Wipe\-To\-Lower\-Left\{Lower\-Right,Upper\-Left.\-Upper\-Right\} -\/ 3 of one input and 1 of the other. Select the location of input 0 to the Lower\-Left\{Lower\-Right,Upper\-Left,Upper\-Right\}. Position selects the location of the corner. Set\-Wipe\-To\-Horizontal -\/ alternate input 0 and input 1 with a vertical split. Position\mbox{[}0\mbox{]} specifies the location of the vertical transition between input 0 and input 1. Set\-Wipe\-To\-Vertical -\/ alternate input 0 and input 1 with a horizontal split. Position\mbox{[}1\mbox{]} specifies the location of the horizonal transition between input 0 and input 1.  
\item {\ttfamily obj.\-Set\-Wipe\-To\-Horizontal ()} -\/ Specify the wipe mode. This mode determnis how input 0 and input 1 are combined to produce the output. Each mode uses one or both of the values stored in Position. Set\-Wipe\-To\-Quad -\/ alternate input 0 and input 1 horizontally and vertically. The Position specifies the location of the quad intersection. Set\-Wipe\-To\-Lower\-Left\{Lower\-Right,Upper\-Left.\-Upper\-Right\} -\/ 3 of one input and 1 of the other. Select the location of input 0 to the Lower\-Left\{Lower\-Right,Upper\-Left,Upper\-Right\}. Position selects the location of the corner. Set\-Wipe\-To\-Horizontal -\/ alternate input 0 and input 1 with a vertical split. Position\mbox{[}0\mbox{]} specifies the location of the vertical transition between input 0 and input 1. Set\-Wipe\-To\-Vertical -\/ alternate input 0 and input 1 with a horizontal split. Position\mbox{[}1\mbox{]} specifies the location of the horizonal transition between input 0 and input 1.  
\item {\ttfamily obj.\-Set\-Wipe\-To\-Vertical ()} -\/ Specify the wipe mode. This mode determnis how input 0 and input 1 are combined to produce the output. Each mode uses one or both of the values stored in Position. Set\-Wipe\-To\-Quad -\/ alternate input 0 and input 1 horizontally and vertically. The Position specifies the location of the quad intersection. Set\-Wipe\-To\-Lower\-Left\{Lower\-Right,Upper\-Left.\-Upper\-Right\} -\/ 3 of one input and 1 of the other. Select the location of input 0 to the Lower\-Left\{Lower\-Right,Upper\-Left,Upper\-Right\}. Position selects the location of the corner. Set\-Wipe\-To\-Horizontal -\/ alternate input 0 and input 1 with a vertical split. Position\mbox{[}0\mbox{]} specifies the location of the vertical transition between input 0 and input 1. Set\-Wipe\-To\-Vertical -\/ alternate input 0 and input 1 with a horizontal split. Position\mbox{[}1\mbox{]} specifies the location of the horizonal transition between input 0 and input 1.  
\item {\ttfamily obj.\-Set\-Wipe\-To\-Lower\-Left ()} -\/ Specify the wipe mode. This mode determnis how input 0 and input 1 are combined to produce the output. Each mode uses one or both of the values stored in Position. Set\-Wipe\-To\-Quad -\/ alternate input 0 and input 1 horizontally and vertically. The Position specifies the location of the quad intersection. Set\-Wipe\-To\-Lower\-Left\{Lower\-Right,Upper\-Left.\-Upper\-Right\} -\/ 3 of one input and 1 of the other. Select the location of input 0 to the Lower\-Left\{Lower\-Right,Upper\-Left,Upper\-Right\}. Position selects the location of the corner. Set\-Wipe\-To\-Horizontal -\/ alternate input 0 and input 1 with a vertical split. Position\mbox{[}0\mbox{]} specifies the location of the vertical transition between input 0 and input 1. Set\-Wipe\-To\-Vertical -\/ alternate input 0 and input 1 with a horizontal split. Position\mbox{[}1\mbox{]} specifies the location of the horizonal transition between input 0 and input 1.  
\item {\ttfamily obj.\-Set\-Wipe\-To\-Lower\-Right ()} -\/ Specify the wipe mode. This mode determnis how input 0 and input 1 are combined to produce the output. Each mode uses one or both of the values stored in Position. Set\-Wipe\-To\-Quad -\/ alternate input 0 and input 1 horizontally and vertically. The Position specifies the location of the quad intersection. Set\-Wipe\-To\-Lower\-Left\{Lower\-Right,Upper\-Left.\-Upper\-Right\} -\/ 3 of one input and 1 of the other. Select the location of input 0 to the Lower\-Left\{Lower\-Right,Upper\-Left,Upper\-Right\}. Position selects the location of the corner. Set\-Wipe\-To\-Horizontal -\/ alternate input 0 and input 1 with a vertical split. Position\mbox{[}0\mbox{]} specifies the location of the vertical transition between input 0 and input 1. Set\-Wipe\-To\-Vertical -\/ alternate input 0 and input 1 with a horizontal split. Position\mbox{[}1\mbox{]} specifies the location of the horizonal transition between input 0 and input 1.  
\item {\ttfamily obj.\-Set\-Wipe\-To\-Upper\-Left ()} -\/ Specify the wipe mode. This mode determnis how input 0 and input 1 are combined to produce the output. Each mode uses one or both of the values stored in Position. Set\-Wipe\-To\-Quad -\/ alternate input 0 and input 1 horizontally and vertically. The Position specifies the location of the quad intersection. Set\-Wipe\-To\-Lower\-Left\{Lower\-Right,Upper\-Left.\-Upper\-Right\} -\/ 3 of one input and 1 of the other. Select the location of input 0 to the Lower\-Left\{Lower\-Right,Upper\-Left,Upper\-Right\}. Position selects the location of the corner. Set\-Wipe\-To\-Horizontal -\/ alternate input 0 and input 1 with a vertical split. Position\mbox{[}0\mbox{]} specifies the location of the vertical transition between input 0 and input 1. Set\-Wipe\-To\-Vertical -\/ alternate input 0 and input 1 with a horizontal split. Position\mbox{[}1\mbox{]} specifies the location of the horizonal transition between input 0 and input 1.  
\item {\ttfamily obj.\-Set\-Wipe\-To\-Upper\-Right ()}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageresample}{}\section{vtk\-Image\-Resample}\label{vtkimaging_vtkimageresample}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This filter produces an output with different spacing (and extent) than the input. Linear interpolation can be used to resample the data. The Output spacing can be set explicitly or relative to input spacing with the Set\-Axis\-Magnification\-Factor method.

To create an instance of class vtk\-Image\-Resample, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageResample
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Resample has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Resample class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Resample = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Resample = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Axis\-Output\-Spacing (int axis, double spacing)} -\/ Set desired spacing. Zero is a reserved value indicating spacing has not been set.  
\item {\ttfamily obj.\-Set\-Axis\-Magnification\-Factor (int axis, double factor)} -\/ Set/\-Get Magnification factors. Zero is a reserved value indicating values have not been computed.  
\item {\ttfamily double = obj.\-Get\-Axis\-Magnification\-Factor (int axis, vtk\-Information in\-Info)} -\/ Set/\-Get Magnification factors. Zero is a reserved value indicating values have not been computed.  
\item {\ttfamily obj.\-Set\-Dimensionality (int )} -\/ Dimensionality is the number of axes which are considered during execution. To process images dimensionality would be set to 2. This has the same effect as setting the magnification of the third axis to 1.\-0  
\item {\ttfamily int = obj.\-Get\-Dimensionality ()} -\/ Dimensionality is the number of axes which are considered during execution. To process images dimensionality would be set to 2. This has the same effect as setting the magnification of the third axis to 1.\-0  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagereslice}{}\section{vtk\-Image\-Reslice}\label{vtkimaging_vtkimagereslice}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Reslice is the swiss-\/army-\/knife of image geometry filters\-: It can permute, rotate, flip, scale, resample, deform, and pad image data in any combination with reasonably high efficiency. Simple operations such as permutation, resampling and padding are done with similar efficiently to the specialized vtk\-Image\-Permute, vtk\-Image\-Resample, and vtk\-Image\-Pad filters. There are a number of tasks that vtk\-Image\-Reslice is well suited for\-: 

1) Application of simple rotations, scales, and translations to an image. It is often a good idea to use vtk\-Image\-Change\-Information to center the image first, so that scales and rotations occur around the center rather than around the lower-\/left corner of the image. 

2) Resampling of one data set to match the voxel sampling of a second data set via the Set\-Information\-Input() method, e.\-g. for the purpose of comparing two images or combining two images. A transformation, either linear or nonlinear, can be applied at the same time via the Set\-Reslice\-Transform method if the two images are not in the same coordinate space. 

3) Extraction of slices from an image volume. The most convenient way to do this is to use Set\-Reslice\-Axes\-Direction\-Cosines() to specify the orientation of the slice. The direction cosines give the x, y, and z axes for the output volume. The method Set\-Output\-Dimensionality(2) is used to specify that want to output a slice rather than a volume. The Set\-Reslice\-Axes\-Origin() command is used to provide an (x,y,z) point that the slice will pass through. You can use both the Reslice\-Axes and the Reslice\-Transform at the same time, in order to extract slices from a volume that you have applied a transformation to.

To create an instance of class vtk\-Image\-Reslice, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageReslice
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Reslice has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Reslice class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Reslice = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Reslice = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Reslice\-Axes (vtk\-Matrix4x4 )} -\/ This method is used to set up the axes for the output voxels. The output Spacing, Origin, and Extent specify the locations of the voxels within the coordinate system defined by the axes. The Reslice\-Axes are used most often to permute the data, e.\-g. to extract Z\-Y or X\-Z slices of a volume as 2\-D X\-Y images. 

The first column of the matrix specifies the x-\/axis vector (the fourth element must be set to zero), the second column specifies the y-\/axis, and the third column the z-\/axis. The fourth column is the origin of the axes (the fourth element must be set to one). 

An alternative to Set\-Reslice\-Axes() is to use Set\-Reslice\-Axes\-Direction\-Cosines() to set the directions of the axes and Set\-Reslice\-Axes\-Origin() to set the origin of the axes.  
\item {\ttfamily vtk\-Matrix4x4 = obj.\-Get\-Reslice\-Axes ()} -\/ This method is used to set up the axes for the output voxels. The output Spacing, Origin, and Extent specify the locations of the voxels within the coordinate system defined by the axes. The Reslice\-Axes are used most often to permute the data, e.\-g. to extract Z\-Y or X\-Z slices of a volume as 2\-D X\-Y images. 

The first column of the matrix specifies the x-\/axis vector (the fourth element must be set to zero), the second column specifies the y-\/axis, and the third column the z-\/axis. The fourth column is the origin of the axes (the fourth element must be set to one). 

An alternative to Set\-Reslice\-Axes() is to use Set\-Reslice\-Axes\-Direction\-Cosines() to set the directions of the axes and Set\-Reslice\-Axes\-Origin() to set the origin of the axes.  
\item {\ttfamily obj.\-Set\-Reslice\-Axes\-Direction\-Cosines (double x0, double x1, double x2, double y0, double y1, double y2, double z0, double z1, double z2)} -\/ Specify the direction cosines for the Reslice\-Axes (i.\-e. the first three elements of each of the first three columns of the Reslice\-Axes matrix). This will modify the current Reslice\-Axes matrix, or create a new matrix if none exists.  
\item {\ttfamily obj.\-Set\-Reslice\-Axes\-Direction\-Cosines (double x\mbox{[}3\mbox{]}, double y\mbox{[}3\mbox{]}, double z\mbox{[}3\mbox{]})} -\/ Specify the direction cosines for the Reslice\-Axes (i.\-e. the first three elements of each of the first three columns of the Reslice\-Axes matrix). This will modify the current Reslice\-Axes matrix, or create a new matrix if none exists.  
\item {\ttfamily obj.\-Set\-Reslice\-Axes\-Direction\-Cosines (double xyz\mbox{[}9\mbox{]})} -\/ Specify the direction cosines for the Reslice\-Axes (i.\-e. the first three elements of each of the first three columns of the Reslice\-Axes matrix). This will modify the current Reslice\-Axes matrix, or create a new matrix if none exists.  
\item {\ttfamily obj.\-Get\-Reslice\-Axes\-Direction\-Cosines (double x\mbox{[}3\mbox{]}, double y\mbox{[}3\mbox{]}, double z\mbox{[}3\mbox{]})} -\/ Specify the direction cosines for the Reslice\-Axes (i.\-e. the first three elements of each of the first three columns of the Reslice\-Axes matrix). This will modify the current Reslice\-Axes matrix, or create a new matrix if none exists.  
\item {\ttfamily obj.\-Get\-Reslice\-Axes\-Direction\-Cosines (double xyz\mbox{[}9\mbox{]})} -\/ Specify the direction cosines for the Reslice\-Axes (i.\-e. the first three elements of each of the first three columns of the Reslice\-Axes matrix). This will modify the current Reslice\-Axes matrix, or create a new matrix if none exists.  
\item {\ttfamily double = obj.\-Get\-Reslice\-Axes\-Direction\-Cosines ()} -\/ Specify the direction cosines for the Reslice\-Axes (i.\-e. the first three elements of each of the first three columns of the Reslice\-Axes matrix). This will modify the current Reslice\-Axes matrix, or create a new matrix if none exists.  
\item {\ttfamily obj.\-Set\-Reslice\-Axes\-Origin (double x, double y, double z)} -\/ Specify the origin for the Reslice\-Axes (i.\-e. the first three elements of the final column of the Reslice\-Axes matrix). This will modify the current Reslice\-Axes matrix, or create new matrix if none exists.  
\item {\ttfamily obj.\-Set\-Reslice\-Axes\-Origin (double xyz\mbox{[}3\mbox{]})} -\/ Specify the origin for the Reslice\-Axes (i.\-e. the first three elements of the final column of the Reslice\-Axes matrix). This will modify the current Reslice\-Axes matrix, or create new matrix if none exists.  
\item {\ttfamily obj.\-Get\-Reslice\-Axes\-Origin (double xyz\mbox{[}3\mbox{]})} -\/ Specify the origin for the Reslice\-Axes (i.\-e. the first three elements of the final column of the Reslice\-Axes matrix). This will modify the current Reslice\-Axes matrix, or create new matrix if none exists.  
\item {\ttfamily double = obj.\-Get\-Reslice\-Axes\-Origin ()} -\/ Specify the origin for the Reslice\-Axes (i.\-e. the first three elements of the final column of the Reslice\-Axes matrix). This will modify the current Reslice\-Axes matrix, or create new matrix if none exists.  
\item {\ttfamily obj.\-Set\-Reslice\-Transform (vtk\-Abstract\-Transform )} -\/ Set a transform to be applied to the resampling grid that has been defined via the Reslice\-Axes and the output Origin, Spacing and Extent. Note that applying a transform to the resampling grid (which lies in the output coordinate system) is equivalent to applying the inverse of that transform to the input volume. Nonlinear transforms such as vtk\-Grid\-Transform and vtk\-Thin\-Plate\-Spline\-Transform can be used here.  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Get\-Reslice\-Transform ()} -\/ Set a transform to be applied to the resampling grid that has been defined via the Reslice\-Axes and the output Origin, Spacing and Extent. Note that applying a transform to the resampling grid (which lies in the output coordinate system) is equivalent to applying the inverse of that transform to the input volume. Nonlinear transforms such as vtk\-Grid\-Transform and vtk\-Thin\-Plate\-Spline\-Transform can be used here.  
\item {\ttfamily obj.\-Set\-Information\-Input (vtk\-Image\-Data )} -\/ Set a vtk\-Image\-Data from which the default Spacing, Origin, and Whole\-Extent of the output will be copied. The spacing, origin, and extent will be permuted according to the Reslice\-Axes. Any values set via Set\-Output\-Spacing, Set\-Output\-Origin, and Set\-Output\-Extent will override these values. By default, the Spacing, Origin, and Whole\-Extent of the Input are used.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Information\-Input ()} -\/ Set a vtk\-Image\-Data from which the default Spacing, Origin, and Whole\-Extent of the output will be copied. The spacing, origin, and extent will be permuted according to the Reslice\-Axes. Any values set via Set\-Output\-Spacing, Set\-Output\-Origin, and Set\-Output\-Extent will override these values. By default, the Spacing, Origin, and Whole\-Extent of the Input are used.  
\item {\ttfamily obj.\-Set\-Transform\-Input\-Sampling (int )} -\/ Specify whether to transform the spacing, origin and extent of the Input (or the Information\-Input) according to the direction cosines and origin of the Reslice\-Axes before applying them as the default output spacing, origin and extent (default\-: On).  
\item {\ttfamily obj.\-Transform\-Input\-Sampling\-On ()} -\/ Specify whether to transform the spacing, origin and extent of the Input (or the Information\-Input) according to the direction cosines and origin of the Reslice\-Axes before applying them as the default output spacing, origin and extent (default\-: On).  
\item {\ttfamily obj.\-Transform\-Input\-Sampling\-Off ()} -\/ Specify whether to transform the spacing, origin and extent of the Input (or the Information\-Input) according to the direction cosines and origin of the Reslice\-Axes before applying them as the default output spacing, origin and extent (default\-: On).  
\item {\ttfamily int = obj.\-Get\-Transform\-Input\-Sampling ()} -\/ Specify whether to transform the spacing, origin and extent of the Input (or the Information\-Input) according to the direction cosines and origin of the Reslice\-Axes before applying them as the default output spacing, origin and extent (default\-: On).  
\item {\ttfamily obj.\-Set\-Auto\-Crop\-Output (int )} -\/ Turn this on if you want to guarantee that the extent of the output will be large enough to ensure that none of the data will be cropped (default\-: Off).  
\item {\ttfamily obj.\-Auto\-Crop\-Output\-On ()} -\/ Turn this on if you want to guarantee that the extent of the output will be large enough to ensure that none of the data will be cropped (default\-: Off).  
\item {\ttfamily obj.\-Auto\-Crop\-Output\-Off ()} -\/ Turn this on if you want to guarantee that the extent of the output will be large enough to ensure that none of the data will be cropped (default\-: Off).  
\item {\ttfamily int = obj.\-Get\-Auto\-Crop\-Output ()} -\/ Turn this on if you want to guarantee that the extent of the output will be large enough to ensure that none of the data will be cropped (default\-: Off).  
\item {\ttfamily obj.\-Set\-Wrap (int )} -\/ Turn on wrap-\/pad feature (default\-: Off).  
\item {\ttfamily int = obj.\-Get\-Wrap ()} -\/ Turn on wrap-\/pad feature (default\-: Off).  
\item {\ttfamily obj.\-Wrap\-On ()} -\/ Turn on wrap-\/pad feature (default\-: Off).  
\item {\ttfamily obj.\-Wrap\-Off ()} -\/ Turn on wrap-\/pad feature (default\-: Off).  
\item {\ttfamily obj.\-Set\-Mirror (int )} -\/ Turn on mirror-\/pad feature (default\-: Off). This will override the wrap-\/pad.  
\item {\ttfamily int = obj.\-Get\-Mirror ()} -\/ Turn on mirror-\/pad feature (default\-: Off). This will override the wrap-\/pad.  
\item {\ttfamily obj.\-Mirror\-On ()} -\/ Turn on mirror-\/pad feature (default\-: Off). This will override the wrap-\/pad.  
\item {\ttfamily obj.\-Mirror\-Off ()} -\/ Turn on mirror-\/pad feature (default\-: Off). This will override the wrap-\/pad.  
\item {\ttfamily obj.\-Set\-Border (int )} -\/ Extend the apparent input border by a half voxel (default\-: On). This changes how interpolation is handled at the borders of the input image\-: if the center of an output voxel is beyond the edge of the input image, but is within a half voxel width of the edge (using the input voxel width), then the value of the output voxel is calculated as if the input's edge voxels were duplicated past the edges of the input. This has no effect if Mirror or Wrap are on.  
\item {\ttfamily int = obj.\-Get\-Border ()} -\/ Extend the apparent input border by a half voxel (default\-: On). This changes how interpolation is handled at the borders of the input image\-: if the center of an output voxel is beyond the edge of the input image, but is within a half voxel width of the edge (using the input voxel width), then the value of the output voxel is calculated as if the input's edge voxels were duplicated past the edges of the input. This has no effect if Mirror or Wrap are on.  
\item {\ttfamily obj.\-Border\-On ()} -\/ Extend the apparent input border by a half voxel (default\-: On). This changes how interpolation is handled at the borders of the input image\-: if the center of an output voxel is beyond the edge of the input image, but is within a half voxel width of the edge (using the input voxel width), then the value of the output voxel is calculated as if the input's edge voxels were duplicated past the edges of the input. This has no effect if Mirror or Wrap are on.  
\item {\ttfamily obj.\-Border\-Off ()} -\/ Extend the apparent input border by a half voxel (default\-: On). This changes how interpolation is handled at the borders of the input image\-: if the center of an output voxel is beyond the edge of the input image, but is within a half voxel width of the edge (using the input voxel width), then the value of the output voxel is calculated as if the input's edge voxels were duplicated past the edges of the input. This has no effect if Mirror or Wrap are on.  
\item {\ttfamily obj.\-Set\-Interpolation\-Mode (int )} -\/ Set interpolation mode (default\-: nearest neighbor).  
\item {\ttfamily int = obj.\-Get\-Interpolation\-Mode\-Min\-Value ()} -\/ Set interpolation mode (default\-: nearest neighbor).  
\item {\ttfamily int = obj.\-Get\-Interpolation\-Mode\-Max\-Value ()} -\/ Set interpolation mode (default\-: nearest neighbor).  
\item {\ttfamily int = obj.\-Get\-Interpolation\-Mode ()} -\/ Set interpolation mode (default\-: nearest neighbor).  
\item {\ttfamily obj.\-Set\-Interpolation\-Mode\-To\-Nearest\-Neighbor ()} -\/ Set interpolation mode (default\-: nearest neighbor).  
\item {\ttfamily obj.\-Set\-Interpolation\-Mode\-To\-Linear ()} -\/ Set interpolation mode (default\-: nearest neighbor).  
\item {\ttfamily obj.\-Set\-Interpolation\-Mode\-To\-Cubic ()} -\/ Set interpolation mode (default\-: nearest neighbor).  
\item {\ttfamily string = obj.\-Get\-Interpolation\-Mode\-As\-String ()} -\/ Set interpolation mode (default\-: nearest neighbor).  
\item {\ttfamily obj.\-Set\-Optimization (int )} -\/ Turn on and off optimizations (default on, they should only be turned off for testing purposes).  
\item {\ttfamily int = obj.\-Get\-Optimization ()} -\/ Turn on and off optimizations (default on, they should only be turned off for testing purposes).  
\item {\ttfamily obj.\-Optimization\-On ()} -\/ Turn on and off optimizations (default on, they should only be turned off for testing purposes).  
\item {\ttfamily obj.\-Optimization\-Off ()} -\/ Turn on and off optimizations (default on, they should only be turned off for testing purposes).  
\item {\ttfamily obj.\-Set\-Background\-Color (double , double , double , double )} -\/ Set the background color (for multi-\/component images).  
\item {\ttfamily obj.\-Set\-Background\-Color (double a\mbox{[}4\mbox{]})} -\/ Set the background color (for multi-\/component images).  
\item {\ttfamily double = obj. Get\-Background\-Color ()} -\/ Set the background color (for multi-\/component images).  
\item {\ttfamily obj.\-Set\-Background\-Level (double v)} -\/ Set background grey level (for single-\/component images).  
\item {\ttfamily double = obj.\-Get\-Background\-Level ()} -\/ Set background grey level (for single-\/component images).  
\item {\ttfamily obj.\-Set\-Output\-Spacing (double , double , double )} -\/ Set the voxel spacing for the output data. The default output spacing is the input spacing permuted through the Reslice\-Axes.  
\item {\ttfamily obj.\-Set\-Output\-Spacing (double a\mbox{[}3\mbox{]})} -\/ Set the voxel spacing for the output data. The default output spacing is the input spacing permuted through the Reslice\-Axes.  
\item {\ttfamily double = obj. Get\-Output\-Spacing ()} -\/ Set the voxel spacing for the output data. The default output spacing is the input spacing permuted through the Reslice\-Axes.  
\item {\ttfamily obj.\-Set\-Output\-Spacing\-To\-Default ()} -\/ Set the voxel spacing for the output data. The default output spacing is the input spacing permuted through the Reslice\-Axes.  
\item {\ttfamily obj.\-Set\-Output\-Origin (double , double , double )} -\/ Set the origin for the output data. The default output origin is the input origin permuted through the Reslice\-Axes.  
\item {\ttfamily obj.\-Set\-Output\-Origin (double a\mbox{[}3\mbox{]})} -\/ Set the origin for the output data. The default output origin is the input origin permuted through the Reslice\-Axes.  
\item {\ttfamily double = obj. Get\-Output\-Origin ()} -\/ Set the origin for the output data. The default output origin is the input origin permuted through the Reslice\-Axes.  
\item {\ttfamily obj.\-Set\-Output\-Origin\-To\-Default ()} -\/ Set the origin for the output data. The default output origin is the input origin permuted through the Reslice\-Axes.  
\item {\ttfamily obj.\-Set\-Output\-Extent (int , int , int , int , int , int )} -\/ Set the extent for the output data. The default output extent is the input extent permuted through the Reslice\-Axes.  
\item {\ttfamily obj.\-Set\-Output\-Extent (int a\mbox{[}6\mbox{]})} -\/ Set the extent for the output data. The default output extent is the input extent permuted through the Reslice\-Axes.  
\item {\ttfamily int = obj. Get\-Output\-Extent ()} -\/ Set the extent for the output data. The default output extent is the input extent permuted through the Reslice\-Axes.  
\item {\ttfamily obj.\-Set\-Output\-Extent\-To\-Default ()} -\/ Set the extent for the output data. The default output extent is the input extent permuted through the Reslice\-Axes.  
\item {\ttfamily obj.\-Set\-Output\-Dimensionality (int )} -\/ Force the dimensionality of the output to either 1, 2, 3 or 0 (default\-: 3). If the dimensionality is 2\-D, then the Z extent of the output is forced to (0,0) and the Z origin of the output is forced to 0.\-0 (i.\-e. the output extent is confined to the xy plane). If the dimensionality is 1\-D, the output extent is confined to the x axis. For 0\-D, the output extent consists of a single voxel at (0,0,0).  
\item {\ttfamily int = obj.\-Get\-Output\-Dimensionality ()} -\/ Force the dimensionality of the output to either 1, 2, 3 or 0 (default\-: 3). If the dimensionality is 2\-D, then the Z extent of the output is forced to (0,0) and the Z origin of the output is forced to 0.\-0 (i.\-e. the output extent is confined to the xy plane). If the dimensionality is 1\-D, the output extent is confined to the x axis. For 0\-D, the output extent consists of a single voxel at (0,0,0).  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ When determining the modified time of the filter, this check the modified time of the transform and matrix.  
\item {\ttfamily obj.\-Report\-References (vtk\-Garbage\-Collector )} -\/ Report object referenced by instances of this class.  
\item {\ttfamily obj.\-Set\-Interpolate (int t)} -\/ Convenient methods for switching between nearest-\/neighbor and linear interpolation. Interpolate\-On() is equivalent to Set\-Interpolation\-Mode\-To\-Linear() and Interpolate\-Off() is equivalent to Set\-Interpolation\-Mode\-To\-Nearest\-Neighbor(). You should not use these methods if you use the Set\-Interpolation\-Mode methods.  
\item {\ttfamily obj.\-Interpolate\-On ()} -\/ Convenient methods for switching between nearest-\/neighbor and linear interpolation. Interpolate\-On() is equivalent to Set\-Interpolation\-Mode\-To\-Linear() and Interpolate\-Off() is equivalent to Set\-Interpolation\-Mode\-To\-Nearest\-Neighbor(). You should not use these methods if you use the Set\-Interpolation\-Mode methods.  
\item {\ttfamily obj.\-Interpolate\-Off ()} -\/ Convenient methods for switching between nearest-\/neighbor and linear interpolation. Interpolate\-On() is equivalent to Set\-Interpolation\-Mode\-To\-Linear() and Interpolate\-Off() is equivalent to Set\-Interpolation\-Mode\-To\-Nearest\-Neighbor(). You should not use these methods if you use the Set\-Interpolation\-Mode methods.  
\item {\ttfamily int = obj.\-Get\-Interpolate ()} -\/ Convenient methods for switching between nearest-\/neighbor and linear interpolation. Interpolate\-On() is equivalent to Set\-Interpolation\-Mode\-To\-Linear() and Interpolate\-Off() is equivalent to Set\-Interpolation\-Mode\-To\-Nearest\-Neighbor(). You should not use these methods if you use the Set\-Interpolation\-Mode methods.  
\item {\ttfamily obj.\-Set\-Stencil (vtk\-Image\-Stencil\-Data stencil)} -\/ Use a stencil to limit the calculations to a specific region of the output. Portions of the output that are 'outside' the stencil will be cleared to the background color.  
\item {\ttfamily vtk\-Image\-Stencil\-Data = obj.\-Get\-Stencil ()} -\/ Use a stencil to limit the calculations to a specific region of the output. Portions of the output that are 'outside' the stencil will be cleared to the background color.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagerfft}{}\section{vtk\-Image\-R\-F\-F\-T}\label{vtkimaging_vtkimagerfft}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-R\-F\-F\-T implements the reverse fast Fourier transform. The input can have real or complex data in any components and data types, but the output is always complex doubles with real values in component0, and imaginary values in component1. The filter is fastest for images that have power of two sizes. The filter uses a butterfly fitlers for each prime factor of the dimension. This makes images with prime number dimensions (i.\-e. 17x17) much slower to compute. Multi dimensional (i.\-e volumes) F\-F\-T's are decomposed so that each axis executes in series. In most cases the R\-F\-F\-T will produce an image whose imaginary values are all zero's. In this case vtk\-Image\-Extract\-Components can be used to remove this imaginary components leaving only the real image.

To create an instance of class vtk\-Image\-R\-F\-F\-T, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageRFFT
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-R\-F\-F\-T has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-R\-F\-F\-T class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-R\-F\-F\-T = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-R\-F\-F\-T = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Split\-Extent (int split\-Ext\mbox{[}6\mbox{]}, int start\-Ext\mbox{[}6\mbox{]}, int num, int total)} -\/ For streaming and threads. Splits output update extent into num pieces. This method needs to be called num times. Results must not overlap for consistent starting extent. Subclass can override this method. This method returns the number of pieces resulting from a successful split. This can be from 1 to \char`\"{}total\char`\"{}. If 1 is returned, the extent cannot be split.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagergbtohsi}{}\section{vtk\-Image\-R\-G\-B\-To\-H\-S\-I}\label{vtkimaging_vtkimagergbtohsi}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
For each pixel with red, blue, and green components this filter output the color coded as hue, saturation and intensity. Output type must be the same as input type.

To create an instance of class vtk\-Image\-R\-G\-B\-To\-H\-S\-I, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageRGBToHSI
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-R\-G\-B\-To\-H\-S\-I has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-R\-G\-B\-To\-H\-S\-I class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-R\-G\-B\-To\-H\-S\-I = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-R\-G\-B\-To\-H\-S\-I = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Maximum (double )} -\/ Hue is an angle. Maximum specifies when it maps back to 0. Hue\-Maximum defaults to 255 instead of 2\-P\-I, because unsigned char is expected as input. Maximum also specifies the maximum of the Saturation.  
\item {\ttfamily double = obj.\-Get\-Maximum ()} -\/ Hue is an angle. Maximum specifies when it maps back to 0. Hue\-Maximum defaults to 255 instead of 2\-P\-I, because unsigned char is expected as input. Maximum also specifies the maximum of the Saturation.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagergbtohsv}{}\section{vtk\-Image\-R\-G\-B\-To\-H\-S\-V}\label{vtkimaging_vtkimagergbtohsv}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
For each pixel with red, blue, and green components this filter output the color coded as hue, saturation and value. Output type must be the same as input type.

To create an instance of class vtk\-Image\-R\-G\-B\-To\-H\-S\-V, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageRGBToHSV
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-R\-G\-B\-To\-H\-S\-V has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-R\-G\-B\-To\-H\-S\-V class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-R\-G\-B\-To\-H\-S\-V = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-R\-G\-B\-To\-H\-S\-V = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Maximum (double )}  
\item {\ttfamily double = obj.\-Get\-Maximum ()}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageseedconnectivity}{}\section{vtk\-Image\-Seed\-Connectivity}\label{vtkimaging_vtkimageseedconnectivity}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Seed\-Connectivity marks pixels connected to user supplied seeds. The input must be unsigned char, and the output is also unsigned char. If a seed supplied by the user does not have pixel value \char`\"{}\-Input\-True\-Value\char`\"{}, then the image is scanned +x, +y, +z until a pixel is encountered with value \char`\"{}\-Input\-True\-Value\char`\"{}. This new pixel is used as the seed . Any pixel with out value \char`\"{}\-Input\-True\-Value\char`\"{} is consider off. The output pixels values are 0 for any off pixel in input, \char`\"{}\-Output\-True\-Value\char`\"{} for any pixels connected to seeds, and \char`\"{}\-Output\-Unconnected\-Value\char`\"{} for any on pixels not connected to seeds. The same seeds are used for all images in the image set.

To create an instance of class vtk\-Image\-Seed\-Connectivity, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageSeedConnectivity
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Seed\-Connectivity has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Seed\-Connectivity class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Seed\-Connectivity = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Seed\-Connectivity = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Remove\-All\-Seeds ()} -\/ Methods for manipulating the seed pixels.  
\item {\ttfamily obj.\-Add\-Seed (int num, int index)} -\/ Methods for manipulating the seed pixels.  
\item {\ttfamily obj.\-Add\-Seed (int i0, int i1, int i2)} -\/ Methods for manipulating the seed pixels.  
\item {\ttfamily obj.\-Add\-Seed (int i0, int i1)} -\/ Methods for manipulating the seed pixels.  
\item {\ttfamily obj.\-Set\-Input\-Connect\-Value (int )} -\/ Set/\-Get what value is considered as connecting pixels.  
\item {\ttfamily int = obj.\-Get\-Input\-Connect\-Value ()} -\/ Set/\-Get what value is considered as connecting pixels.  
\item {\ttfamily obj.\-Set\-Output\-Connected\-Value (int )} -\/ Set/\-Get the value to set connected pixels to.  
\item {\ttfamily int = obj.\-Get\-Output\-Connected\-Value ()} -\/ Set/\-Get the value to set connected pixels to.  
\item {\ttfamily obj.\-Set\-Output\-Unconnected\-Value (int )} -\/ Set/\-Get the value to set unconnected pixels to.  
\item {\ttfamily int = obj.\-Get\-Output\-Unconnected\-Value ()} -\/ Set/\-Get the value to set unconnected pixels to.  
\item {\ttfamily vtk\-Image\-Connector = obj.\-Get\-Connector ()} -\/ Get the vtk\-Image\-C\-Onnector used by this filter.  
\item {\ttfamily obj.\-Set\-Dimensionality (int )} -\/ Set the number of axes to use in connectivity.  
\item {\ttfamily int = obj.\-Get\-Dimensionality ()} -\/ Set the number of axes to use in connectivity.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageseparableconvolution}{}\section{vtk\-Image\-Separable\-Convolution}\label{vtkimaging_vtkimageseparableconvolution}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Separable\-Convolution performs a convolution along the X, Y, and Z axes of an image, based on the three different 1\-D convolution kernels. The kernels must be of odd size, and are considered to be centered at (int)((kernelsize -\/ 1) / 2.\-0 ). If a kernel is N\-U\-L\-L, that dimension is skipped. This filter is designed to efficiently convolve separable filters that can be decomposed into 1 or more 1\-D convolutions. It also handles arbitrarly large kernel sizes, and uses edge replication to handle boundaries.

To create an instance of class vtk\-Image\-Separable\-Convolution, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageSeparableConvolution
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Separable\-Convolution has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Separable\-Convolution class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Separable\-Convolution = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Separable\-Convolution = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-X\-Kernel (vtk\-Float\-Array )}  
\item {\ttfamily vtk\-Float\-Array = obj.\-Get\-X\-Kernel ()}  
\item {\ttfamily obj.\-Set\-Y\-Kernel (vtk\-Float\-Array )}  
\item {\ttfamily vtk\-Float\-Array = obj.\-Get\-Y\-Kernel ()}  
\item {\ttfamily obj.\-Set\-Z\-Kernel (vtk\-Float\-Array )}  
\item {\ttfamily vtk\-Float\-Array = obj.\-Get\-Z\-Kernel ()}  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Overload standard modified time function. If kernel arrays are modified, then this object is modified as well.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageshiftscale}{}\section{vtk\-Image\-Shift\-Scale}\label{vtkimaging_vtkimageshiftscale}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
With vtk\-Image\-Shift\-Scale Pixels are shifted (a constant value added) and then scaled (multiplied by a scalar. As a convenience, this class allows you to set the output scalar type similar to vtk\-Image\-Cast. This is because shift scale operations frequently convert data types.

To create an instance of class vtk\-Image\-Shift\-Scale, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageShiftScale
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Shift\-Scale has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Shift\-Scale class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Shift\-Scale = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Shift\-Scale = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Shift (double )} -\/ Set/\-Get the shift value. This value is added to each pixel  
\item {\ttfamily double = obj.\-Get\-Shift ()} -\/ Set/\-Get the shift value. This value is added to each pixel  
\item {\ttfamily obj.\-Set\-Scale (double )} -\/ Set/\-Get the scale value. Each pixel is multiplied by this value.  
\item {\ttfamily double = obj.\-Get\-Scale ()} -\/ Set/\-Get the scale value. Each pixel is multiplied by this value.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type (int )} -\/ Set the desired output scalar type. The result of the shift and scale operations is cast to the type specified.  
\item {\ttfamily int = obj.\-Get\-Output\-Scalar\-Type ()} -\/ Set the desired output scalar type. The result of the shift and scale operations is cast to the type specified.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Double ()} -\/ Set the desired output scalar type. The result of the shift and scale operations is cast to the type specified.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Float ()} -\/ Set the desired output scalar type. The result of the shift and scale operations is cast to the type specified.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Long ()} -\/ Set the desired output scalar type. The result of the shift and scale operations is cast to the type specified.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Unsigned\-Long ()} -\/ Set the desired output scalar type. The result of the shift and scale operations is cast to the type specified.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Int ()} -\/ Set the desired output scalar type. The result of the shift and scale operations is cast to the type specified.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Unsigned\-Int ()} -\/ Set the desired output scalar type. The result of the shift and scale operations is cast to the type specified.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Short ()} -\/ Set the desired output scalar type. The result of the shift and scale operations is cast to the type specified.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Unsigned\-Short ()} -\/ Set the desired output scalar type. The result of the shift and scale operations is cast to the type specified.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Char ()} -\/ Set the desired output scalar type. The result of the shift and scale operations is cast to the type specified.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Unsigned\-Char ()} -\/ When the Clamp\-Overflow flag is on, the data is thresholded so that the output value does not exceed the max or min of the data type. By default, Clamp\-Overflow is off.  
\item {\ttfamily obj.\-Set\-Clamp\-Overflow (int )} -\/ When the Clamp\-Overflow flag is on, the data is thresholded so that the output value does not exceed the max or min of the data type. By default, Clamp\-Overflow is off.  
\item {\ttfamily int = obj.\-Get\-Clamp\-Overflow ()} -\/ When the Clamp\-Overflow flag is on, the data is thresholded so that the output value does not exceed the max or min of the data type. By default, Clamp\-Overflow is off.  
\item {\ttfamily obj.\-Clamp\-Overflow\-On ()} -\/ When the Clamp\-Overflow flag is on, the data is thresholded so that the output value does not exceed the max or min of the data type. By default, Clamp\-Overflow is off.  
\item {\ttfamily obj.\-Clamp\-Overflow\-Off ()} -\/ When the Clamp\-Overflow flag is on, the data is thresholded so that the output value does not exceed the max or min of the data type. By default, Clamp\-Overflow is off.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageshrink3d}{}\section{vtk\-Image\-Shrink3\-D}\label{vtkimaging_vtkimageshrink3d}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Shrink3\-D shrinks an image by sub sampling on a uniform grid (integer multiples).

To create an instance of class vtk\-Image\-Shrink3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageShrink3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Shrink3\-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\-Image\-Shrink3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Shrink3\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Shrink3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Shrink\-Factors (int , int , int )} -\/ Set/\-Get the shrink factors  
\item {\ttfamily obj.\-Set\-Shrink\-Factors (int a\mbox{[}3\mbox{]})} -\/ Set/\-Get the shrink factors  
\item {\ttfamily int = obj. Get\-Shrink\-Factors ()} -\/ Set/\-Get the shrink factors  
\item {\ttfamily obj.\-Set\-Shift (int , int , int )} -\/ Set/\-Get the pixel to use as origin.  
\item {\ttfamily obj.\-Set\-Shift (int a\mbox{[}3\mbox{]})} -\/ Set/\-Get the pixel to use as origin.  
\item {\ttfamily int = obj. Get\-Shift ()} -\/ Set/\-Get the pixel to use as origin.  
\item {\ttfamily obj.\-Set\-Averaging (int )} -\/ Choose Mean, Minimum, Maximum, Median or sub sampling. The neighborhood operations are not centered on the sampled pixel. This may cause a half pixel shift in your output image. You can changed \char`\"{}\-Shift\char`\"{} to get around this. vtk\-Image\-Gaussian\-Smooth or vtk\-Image\-Mean with strides.  
\item {\ttfamily int = obj.\-Get\-Averaging ()} -\/ Choose Mean, Minimum, Maximum, Median or sub sampling. The neighborhood operations are not centered on the sampled pixel. This may cause a half pixel shift in your output image. You can changed \char`\"{}\-Shift\char`\"{} to get around this. vtk\-Image\-Gaussian\-Smooth or vtk\-Image\-Mean with strides.  
\item {\ttfamily obj.\-Averaging\-On ()} -\/ Choose Mean, Minimum, Maximum, Median or sub sampling. The neighborhood operations are not centered on the sampled pixel. This may cause a half pixel shift in your output image. You can changed \char`\"{}\-Shift\char`\"{} to get around this. vtk\-Image\-Gaussian\-Smooth or vtk\-Image\-Mean with strides.  
\item {\ttfamily obj.\-Averaging\-Off ()} -\/ Choose Mean, Minimum, Maximum, Median or sub sampling. The neighborhood operations are not centered on the sampled pixel. This may cause a half pixel shift in your output image. You can changed \char`\"{}\-Shift\char`\"{} to get around this. vtk\-Image\-Gaussian\-Smooth or vtk\-Image\-Mean with strides.  
\item {\ttfamily obj.\-Set\-Mean (int )}  
\item {\ttfamily int = obj.\-Get\-Mean ()}  
\item {\ttfamily obj.\-Mean\-On ()}  
\item {\ttfamily obj.\-Mean\-Off ()}  
\item {\ttfamily obj.\-Set\-Minimum (int )}  
\item {\ttfamily int = obj.\-Get\-Minimum ()}  
\item {\ttfamily obj.\-Minimum\-On ()}  
\item {\ttfamily obj.\-Minimum\-Off ()}  
\item {\ttfamily obj.\-Set\-Maximum (int )}  
\item {\ttfamily int = obj.\-Get\-Maximum ()}  
\item {\ttfamily obj.\-Maximum\-On ()}  
\item {\ttfamily obj.\-Maximum\-Off ()}  
\item {\ttfamily obj.\-Set\-Median (int )}  
\item {\ttfamily int = obj.\-Get\-Median ()}  
\item {\ttfamily obj.\-Median\-On ()}  
\item {\ttfamily obj.\-Median\-Off ()}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagesinusoidsource}{}\section{vtk\-Image\-Sinusoid\-Source}\label{vtkimaging_vtkimagesinusoidsource}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Sinusoid\-Source just produces images with pixel values determined by a sinusoid.

To create an instance of class vtk\-Image\-Sinusoid\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageSinusoidSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Sinusoid\-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\-Image\-Sinusoid\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Sinusoid\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Sinusoid\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Whole\-Extent (int x\-Minx, int x\-Max, int y\-Min, int y\-Max, int z\-Min, int z\-Max)} -\/ Set/\-Get the extent of the whole output image.  
\item {\ttfamily obj.\-Set\-Direction (double , double , double )} -\/ Set/\-Get the direction vector which determines the sinusoidal orientation. The magnitude is ignored.  
\item {\ttfamily obj.\-Set\-Direction (double dir\mbox{[}3\mbox{]})} -\/ Set/\-Get the direction vector which determines the sinusoidal orientation. The magnitude is ignored.  
\item {\ttfamily double = obj. Get\-Direction ()} -\/ Set/\-Get the direction vector which determines the sinusoidal orientation. The magnitude is ignored.  
\item {\ttfamily obj.\-Set\-Period (double )} -\/ Set/\-Get the period of the sinusoid in pixels.  
\item {\ttfamily double = obj.\-Get\-Period ()} -\/ Set/\-Get the period of the sinusoid in pixels.  
\item {\ttfamily obj.\-Set\-Phase (double )} -\/ Set/\-Get the phase\-: 0-\/$>$2\-Pi. 0 =$>$ Cosine, pi/2 =$>$ Sine.  
\item {\ttfamily double = obj.\-Get\-Phase ()} -\/ Set/\-Get the phase\-: 0-\/$>$2\-Pi. 0 =$>$ Cosine, pi/2 =$>$ Sine.  
\item {\ttfamily obj.\-Set\-Amplitude (double )} -\/ Set/\-Get the magnitude of the sinusoid.  
\item {\ttfamily double = obj.\-Get\-Amplitude ()} -\/ Set/\-Get the magnitude of the sinusoid.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageskeleton2d}{}\section{vtk\-Image\-Skeleton2\-D}\label{vtkimaging_vtkimageskeleton2d}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Skeleton2\-D should leave only single pixel width lines of non-\/zero-\/valued pixels (values of 1 are not allowed). It works by erosion on a 3x3 neighborhood with special rules. The number of iterations determines how far the filter can erode. There are three pruning levels\-: prune == 0 will leave traces on all angles... prune == 1 will not leave traces on 135 degree angles, but will on 90. prune == 2 does not leave traces on any angles leaving only closed loops. Prune defaults to zero. The output scalar type is the same as the input.

To create an instance of class vtk\-Image\-Skeleton2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageSkeleton2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Skeleton2\-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\-Image\-Skeleton2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Skeleton2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Skeleton2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Prune (int )} -\/ When prune is on, only closed loops are left unchanged.  
\item {\ttfamily int = obj.\-Get\-Prune ()} -\/ When prune is on, only closed loops are left unchanged.  
\item {\ttfamily obj.\-Prune\-On ()} -\/ When prune is on, only closed loops are left unchanged.  
\item {\ttfamily obj.\-Prune\-Off ()} -\/ When prune is on, only closed loops are left unchanged.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Iterations (int num)} -\/ Sets the number of cycles in the erosion.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagesobel2d}{}\section{vtk\-Image\-Sobel2\-D}\label{vtkimaging_vtkimagesobel2d}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Sobel2\-D computes a vector field from a scalar field by using Sobel functions. The number of vector components is 2 because the input is an image. Output is always doubles.

To create an instance of class vtk\-Image\-Sobel2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageSobel2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Sobel2\-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\-Image\-Sobel2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Sobel2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Sobel2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagesobel3d}{}\section{vtk\-Image\-Sobel3\-D}\label{vtkimaging_vtkimagesobel3d}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Sobel3\-D computes a vector field from a scalar field by using Sobel functions. The number of vector components is 3 because the input is a volume. Output is always doubles. A little creative liberty was used to extend the 2\-D sobel kernels into 3\-D.

To create an instance of class vtk\-Image\-Sobel3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageSobel3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Sobel3\-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\-Image\-Sobel3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Sobel3\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Sobel3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagespatialalgorithm}{}\section{vtk\-Image\-Spatial\-Algorithm}\label{vtkimaging_vtkimagespatialalgorithm}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Spatial\-Algorithm is a super class for filters that operate on an input neighborhood for each output pixel. It handles even sized neighborhoods, but their can be a half pixel shift associated with processing. This superclass has some logic for handling boundaries. It can split regions into boundary and non-\/boundary pieces and call different execute methods.

To create an instance of class vtk\-Image\-Spatial\-Algorithm, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageSpatialAlgorithm
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Spatial\-Algorithm has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Spatial\-Algorithm class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Spatial\-Algorithm = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Spatial\-Algorithm = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj. Get\-Kernel\-Size ()} -\/ Get the Kernel size.  
\item {\ttfamily int = obj. Get\-Kernel\-Middle ()} -\/ Get the Kernel middle.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagespatialfilter}{}\section{vtk\-Image\-Spatial\-Filter}\label{vtkimaging_vtkimagespatialfilter}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Spatial\-Filter is a super class for filters that operate on an input neighborhood for each output pixel. It handles even sized neighborhoods, but their can be a half pixel shift associated with processing. This superclass has some logic for handling boundaries. It can split regions into boundary and non-\/boundary pieces and call different execute methods. .S\-E\-C\-T\-I\-O\-N Warning This used to be the parent class for most imaging filter in V\-T\-K4.\-x, now this role has been replaced by vtk\-Image\-Spatial\-Algorithm. You should consider using vtk\-Image\-Spatial\-Algorithm instead, when writing filter for V\-T\-K5 and above. This class was kept to ensure full backward compatibility. .S\-E\-C\-T\-I\-O\-N See also vtk\-Simple\-Image\-To\-Image\-Filter vtk\-Image\-To\-Image\-Filter vtk\-Image\-Spatial\-Algorithm

To create an instance of class vtk\-Image\-Spatial\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageSpatialFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Spatial\-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\-Spatial\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Spatial\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Spatial\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj. Get\-Kernel\-Size ()} -\/ Get the Kernel size.  
\item {\ttfamily int = obj. Get\-Kernel\-Middle ()} -\/ Get the Kernel middle.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagestencil}{}\section{vtk\-Image\-Stencil}\label{vtkimaging_vtkimagestencil}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Stencil will combine two images together using a stencil. The stencil should be provided in the form of a vtk\-Image\-Stencil\-Data,

To create an instance of class vtk\-Image\-Stencil, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageStencil
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Stencil has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Stencil class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Stencil = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Stencil = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Stencil (vtk\-Image\-Stencil\-Data stencil)} -\/ Specify the stencil to use. The stencil can be created from a vtk\-Implicit\-Function or a vtk\-Poly\-Data.  
\item {\ttfamily vtk\-Image\-Stencil\-Data = obj.\-Get\-Stencil ()} -\/ Specify the stencil to use. The stencil can be created from a vtk\-Implicit\-Function or a vtk\-Poly\-Data.  
\item {\ttfamily obj.\-Set\-Reverse\-Stencil (int )} -\/ Reverse the stencil.  
\item {\ttfamily obj.\-Reverse\-Stencil\-On ()} -\/ Reverse the stencil.  
\item {\ttfamily obj.\-Reverse\-Stencil\-Off ()} -\/ Reverse the stencil.  
\item {\ttfamily int = obj.\-Get\-Reverse\-Stencil ()} -\/ Reverse the stencil.  
\item {\ttfamily obj.\-Set\-Background\-Input (vtk\-Image\-Data input)} -\/ N\-O\-T\-E\-: Not yet implemented, use Set\-Background\-Value instead. Set the second input. This image will be used for the 'outside' of the stencil. If not set, the output voxels will be filled with Background\-Value instead.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Background\-Input ()} -\/ N\-O\-T\-E\-: Not yet implemented, use Set\-Background\-Value instead. Set the second input. This image will be used for the 'outside' of the stencil. If not set, the output voxels will be filled with Background\-Value instead.  
\item {\ttfamily obj.\-Set\-Background\-Value (double val)} -\/ Set the default output value to use when the second input is not set.  
\item {\ttfamily double = obj.\-Get\-Background\-Value ()} -\/ Set the default output value to use when the second input is not set.  
\item {\ttfamily obj.\-Set\-Background\-Color (double , double , double , double )} -\/ Set the default color to use when the second input is not set. This is like Set\-Background\-Value, but for multi-\/component images.  
\item {\ttfamily obj.\-Set\-Background\-Color (double a\mbox{[}4\mbox{]})} -\/ Set the default color to use when the second input is not set. This is like Set\-Background\-Value, but for multi-\/component images.  
\item {\ttfamily double = obj. Get\-Background\-Color ()} -\/ Set the default color to use when the second input is not set. This is like Set\-Background\-Value, but for multi-\/component images.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagestencildata}{}\section{vtk\-Image\-Stencil\-Data}\label{vtkimaging_vtkimagestencildata}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Stencil\-Data describes an image stencil in a manner which is efficient both in terms of speed and storage space. The stencil extents are stored for each x-\/row across the image (multiple extents per row if necessary) and can be retrieved via the Get\-Next\-Extent() method.

To create an instance of class vtk\-Image\-Stencil\-Data, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageStencilData
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Stencil\-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\-Image\-Stencil\-Data class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Stencil\-Data = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Stencil\-Data = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Initialize ()}  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Data\-Object o)}  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Data\-Object f)}  
\item {\ttfamily obj.\-Internal\-Image\-Stencil\-Data\-Copy (vtk\-Image\-Stencil\-Data s)}  
\item {\ttfamily int = obj.\-Get\-Data\-Object\-Type ()} -\/ The extent type is 3\-D, just like vtk\-Image\-Data.  
\item {\ttfamily int = obj.\-Get\-Extent\-Type ()} -\/ The extent type is 3\-D, just like vtk\-Image\-Data.  
\item {\ttfamily obj.\-Insert\-Next\-Extent (int r1, int r2, int y\-Idx, int z\-Idx)} -\/ This method is used by vtk\-Image\-Stencil\-Data\-Source to add an x sub extent \mbox{[}r1,r2\mbox{]} for the x row (y\-Idx,z\-Idx). The specified sub extent must not intersect any other sub extents along the same x row. As well, r1 and r2 must both be within the total x extent \mbox{[}Extent\mbox{[}0\mbox{]},Extent\mbox{[}1\mbox{]}\mbox{]}.  
\item {\ttfamily obj.\-Insert\-And\-Merge\-Extent (int r1, int r2, int y\-Idx, int z\-Idx)} -\/ Similar to Insert\-Next\-Extent, except that the extent (r1,r2) at y\-Idx, z\-Idx is merged with other extents, (if any) on that row. So a unique extent may not necessarily be added. For instance, if an extent \mbox{[}5,11\mbox{]} already exists adding an extent, \mbox{[}7,9\mbox{]} will not affect the stencil. Likewise adding \mbox{[}10, 13\mbox{]} will replace the existing extent with \mbox{[}5,13\mbox{]}.  
\item {\ttfamily obj.\-Remove\-Extent (int r1, int r2, int y\-Idx, int z\-Idx)} -\/ Remove the extent from (r1,r2) at y\-Idx, z\-Idx  
\item {\ttfamily obj.\-Set\-Spacing (double , double , double )} -\/ Set the desired spacing for the stencil. This must be called before the stencil is Updated, ideally in the Execute\-Information method of the imaging filter that is using the stencil.  
\item {\ttfamily obj.\-Set\-Spacing (double a\mbox{[}3\mbox{]})} -\/ Set the desired spacing for the stencil. This must be called before the stencil is Updated, ideally in the Execute\-Information method of the imaging filter that is using the stencil.  
\item {\ttfamily double = obj. Get\-Spacing ()} -\/ Set the desired spacing for the stencil. This must be called before the stencil is Updated, ideally in the Execute\-Information method of the imaging filter that is using the stencil.  
\item {\ttfamily obj.\-Set\-Origin (double , double , double )} -\/ Set the desired origin for the stencil. This must be called before the stencil is Updated, ideally in the Execute\-Information method of the imaging filter that is using the stencil.  
\item {\ttfamily obj.\-Set\-Origin (double a\mbox{[}3\mbox{]})} -\/ Set the desired origin for the stencil. This must be called before the stencil is Updated, ideally in the Execute\-Information method of the imaging filter that is using the stencil.  
\item {\ttfamily double = obj. Get\-Origin ()} -\/ Set the desired origin for the stencil. This must be called before the stencil is Updated, ideally in the Execute\-Information method of the imaging filter that is using the stencil.  
\item {\ttfamily obj.\-Set\-Extent (int extent\mbox{[}6\mbox{]})} -\/ Set the extent of the data. This is should be called only by vtk\-Image\-Stencil\-Source, as it is part of the basic pipeline functionality.  
\item {\ttfamily obj.\-Set\-Extent (int x1, int x2, int y1, int y2, int z1, int z2)} -\/ Set the extent of the data. This is should be called only by vtk\-Image\-Stencil\-Source, as it is part of the basic pipeline functionality.  
\item {\ttfamily int = obj. Get\-Extent ()} -\/ Set the extent of the data. This is should be called only by vtk\-Image\-Stencil\-Source, as it is part of the basic pipeline functionality.  
\item {\ttfamily obj.\-Allocate\-Extents ()} -\/ Allocate space for the sub-\/extents. This is called by vtk\-Image\-Stencil\-Source.  
\item {\ttfamily obj.\-Fill ()} -\/ Fill the sub-\/extents.  
\item {\ttfamily obj.\-Copy\-Information\-To\-Pipeline (vtk\-Information request, vtk\-Information input, vtk\-Information output, int force\-Copy)} -\/ Override these to handle origin, spacing, scalar type, and scalar number of components. See vtk\-Data\-Object for details.  
\item {\ttfamily obj.\-Copy\-Information\-From\-Pipeline (vtk\-Information request)} -\/ Override these to handle origin, spacing, scalar type, and scalar number of components. See vtk\-Data\-Object for details.  
\item {\ttfamily obj.\-Add (vtk\-Image\-Stencil\-Data )} -\/ Add merges the stencil supplied as argument into Self.  
\item {\ttfamily obj.\-Subtract (vtk\-Image\-Stencil\-Data )} -\/ Subtract removes the portion of the stencil, supplied as argument, that lies within Self from Self.  
\item {\ttfamily obj.\-Replace (vtk\-Image\-Stencil\-Data )} -\/ Replaces the portion of the stencil, supplied as argument, that lies within Self from Self.  
\item {\ttfamily int = obj.\-Clip (int extent\mbox{[}6\mbox{]})} -\/ Clip the stencil with the supplied extents. In other words, discard data outside the specified extents. Return 1 if something changed.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagestencilsource}{}\section{vtk\-Image\-Stencil\-Source}\label{vtkimaging_vtkimagestencilsource}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Stencil\-Source is a superclass for filters that generate image stencils. Given a clipping object such as a vtk\-Implicit\-Function, it will set up a list of clipping extents for each x-\/row through the image data. The extents for each x-\/row can be retrieved via the Get\-Next\-Extent() method after the extent lists have been built with the Build\-Extents() method. For large images, using clipping extents is much more memory efficient (and slightly more time-\/efficient) than building a mask. This class can be subclassed to allow clipping with objects other than vtk\-Implicit\-Function.

To create an instance of class vtk\-Image\-Stencil\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageStencilSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Stencil\-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\-Image\-Stencil\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Stencil\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Stencil\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Output (vtk\-Image\-Stencil\-Data output)} -\/ Get or set the output for this source.  
\item {\ttfamily vtk\-Image\-Stencil\-Data = obj.\-Get\-Output ()} -\/ Get or set the output for this source.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagethreshold}{}\section{vtk\-Image\-Threshold}\label{vtkimaging_vtkimagethreshold}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Threshold can do binary or continuous thresholding for lower, upper or a range of data. The output data type may be different than the output, but defaults to the same type.

To create an instance of class vtk\-Image\-Threshold, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageThreshold
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-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\-Image\-Threshold class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Threshold = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Threshold = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Threshold\-By\-Upper (double thresh)} -\/ The values greater than or equal to the value match.  
\item {\ttfamily obj.\-Threshold\-By\-Lower (double thresh)} -\/ The values less than or equal to the value match.  
\item {\ttfamily obj.\-Threshold\-Between (double lower, double upper)} -\/ The values in a range (inclusive) match  
\item {\ttfamily obj.\-Set\-Replace\-In (int )} -\/ Determines whether to replace the pixel in range with In\-Value  
\item {\ttfamily int = obj.\-Get\-Replace\-In ()} -\/ Determines whether to replace the pixel in range with In\-Value  
\item {\ttfamily obj.\-Replace\-In\-On ()} -\/ Determines whether to replace the pixel in range with In\-Value  
\item {\ttfamily obj.\-Replace\-In\-Off ()} -\/ Determines whether to replace the pixel in range with In\-Value  
\item {\ttfamily obj.\-Set\-In\-Value (double val)} -\/ Replace the in range pixels with this value.  
\item {\ttfamily double = obj.\-Get\-In\-Value ()} -\/ Replace the in range pixels with this value.  
\item {\ttfamily obj.\-Set\-Replace\-Out (int )} -\/ Determines whether to replace the pixel out of range with Out\-Value  
\item {\ttfamily int = obj.\-Get\-Replace\-Out ()} -\/ Determines whether to replace the pixel out of range with Out\-Value  
\item {\ttfamily obj.\-Replace\-Out\-On ()} -\/ Determines whether to replace the pixel out of range with Out\-Value  
\item {\ttfamily obj.\-Replace\-Out\-Off ()} -\/ Determines whether to replace the pixel out of range with Out\-Value  
\item {\ttfamily obj.\-Set\-Out\-Value (double val)} -\/ Replace the in range pixels with this value.  
\item {\ttfamily double = obj.\-Get\-Out\-Value ()} -\/ Replace the in range pixels with this value.  
\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\-Output\-Scalar\-Type (int )} -\/ Set the desired output scalar type to cast to  
\item {\ttfamily int = obj.\-Get\-Output\-Scalar\-Type ()} -\/ Set the desired output scalar type to cast to  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Double ()} -\/ Set the desired output scalar type to cast to  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Float ()} -\/ Set the desired output scalar type to cast to  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Long ()} -\/ Set the desired output scalar type to cast to  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Unsigned\-Long ()} -\/ Set the desired output scalar type to cast to  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Int ()} -\/ Set the desired output scalar type to cast to  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Unsigned\-Int ()} -\/ Set the desired output scalar type to cast to  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Short ()} -\/ Set the desired output scalar type to cast to  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Unsigned\-Short ()} -\/ Set the desired output scalar type to cast to  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Char ()} -\/ Set the desired output scalar type to cast to  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Signed\-Char ()} -\/ Set the desired output scalar type to cast to  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Unsigned\-Char ()}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagetoimagestencil}{}\section{vtk\-Image\-To\-Image\-Stencil}\label{vtkimaging_vtkimagetoimagestencil}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-To\-Image\-Stencil will convert a vtk\-Image\-Data into an stencil that can be used with vtk\-Image\-Stecil or other vtk classes that apply a stencil to an image.

To create an instance of class vtk\-Image\-To\-Image\-Stencil, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageToImageStencil
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-To\-Image\-Stencil has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-To\-Image\-Stencil class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-To\-Image\-Stencil = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-To\-Image\-Stencil = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Input (vtk\-Image\-Data input)} -\/ Specify the image data to convert into a stencil.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Input ()} -\/ Specify the image data to convert into a stencil.  
\item {\ttfamily obj.\-Threshold\-By\-Upper (double thresh)} -\/ The values greater than or equal to the value match.  
\item {\ttfamily obj.\-Threshold\-By\-Lower (double thresh)} -\/ The values less than or equal to the value match.  
\item {\ttfamily obj.\-Threshold\-Between (double lower, double upper)} -\/ The values in a range (inclusive) match  
\item {\ttfamily obj.\-Set\-Upper\-Threshold (double )} -\/ Get the Upper and Lower thresholds.  
\item {\ttfamily double = obj.\-Get\-Upper\-Threshold ()} -\/ Get the Upper and Lower thresholds.  
\item {\ttfamily obj.\-Set\-Lower\-Threshold (double )} -\/ Get the Upper and Lower thresholds.  
\item {\ttfamily double = obj.\-Get\-Lower\-Threshold ()} -\/ Get the Upper and Lower thresholds.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagetranslateextent}{}\section{vtk\-Image\-Translate\-Extent}\label{vtkimaging_vtkimagetranslateextent}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Translate\-Extent shift the whole extent, but does not change the data.

To create an instance of class vtk\-Image\-Translate\-Extent, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageTranslateExtent
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Translate\-Extent has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Translate\-Extent class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Translate\-Extent = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Translate\-Extent = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Translation (int , int , int )} -\/ Delta to change \char`\"{}\-Whole\-Extent\char`\"{}. -\/1 changes 0-\/$>$10 to -\/1-\/$>$9.  
\item {\ttfamily obj.\-Set\-Translation (int a\mbox{[}3\mbox{]})} -\/ Delta to change \char`\"{}\-Whole\-Extent\char`\"{}. -\/1 changes 0-\/$>$10 to -\/1-\/$>$9.  
\item {\ttfamily int = obj. Get\-Translation ()} -\/ Delta to change \char`\"{}\-Whole\-Extent\char`\"{}. -\/1 changes 0-\/$>$10 to -\/1-\/$>$9.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagevariance3d}{}\section{vtk\-Image\-Variance3\-D}\label{vtkimaging_vtkimagevariance3d}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Variance3\-D replaces each pixel with a measurement of pixel variance in a elliptical neighborhood centered on that pixel. The value computed is not exactly the variance. The difference between the neighbor values and center value is computed and squared for each neighbor. These values are summed and divided by the total number of neighbors to produce the output value.

To create an instance of class vtk\-Image\-Variance3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageVariance3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Variance3\-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\-Image\-Variance3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Variance3\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Variance3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Kernel\-Size (int size0, int size1, int size2)} -\/ This method sets the size of the neighborhood. It also sets the default middle of the neighborhood and computes the Elliptical foot print.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimageweightedsum}{}\section{vtk\-Image\-Weighted\-Sum}\label{vtkimaging_vtkimageweightedsum}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
All weights are normalized so they will sum to 1. Images must have the same extents. Output is

.S\-E\-C\-T\-I\-O\-N Thanks The original author of this class is Lauren O'Donnell (M\-I\-T) for Slicer

To create an instance of class vtk\-Image\-Weighted\-Sum, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageWeightedSum
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Weighted\-Sum has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Weighted\-Sum class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Weighted\-Sum = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Weighted\-Sum = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Weights (vtk\-Double\-Array )} -\/ The weights control the contribution of each input to the sum. They will be normalized to sum to 1 before filter execution.  
\item {\ttfamily vtk\-Double\-Array = obj.\-Get\-Weights ()} -\/ The weights control the contribution of each input to the sum. They will be normalized to sum to 1 before filter execution.  
\item {\ttfamily obj.\-Set\-Weight (vtk\-Id\-Type id, double weight)} -\/ Change a specific weight. Reallocation is done  
\item {\ttfamily int = obj.\-Get\-Normalize\-By\-Weight ()} -\/ Setting Normalize\-By\-Weight on will divide the final result by the total weight of the component functions. This process does not otherwise normalize the weighted sum By default, Normalize\-By\-Weight is on.  
\item {\ttfamily obj.\-Set\-Normalize\-By\-Weight (int )} -\/ Setting Normalize\-By\-Weight on will divide the final result by the total weight of the component functions. This process does not otherwise normalize the weighted sum By default, Normalize\-By\-Weight is on.  
\item {\ttfamily int = obj.\-Get\-Normalize\-By\-Weight\-Min\-Value ()} -\/ Setting Normalize\-By\-Weight on will divide the final result by the total weight of the component functions. This process does not otherwise normalize the weighted sum By default, Normalize\-By\-Weight is on.  
\item {\ttfamily int = obj.\-Get\-Normalize\-By\-Weight\-Max\-Value ()} -\/ Setting Normalize\-By\-Weight on will divide the final result by the total weight of the component functions. This process does not otherwise normalize the weighted sum By default, Normalize\-By\-Weight is on.  
\item {\ttfamily obj.\-Normalize\-By\-Weight\-On ()} -\/ Setting Normalize\-By\-Weight on will divide the final result by the total weight of the component functions. This process does not otherwise normalize the weighted sum By default, Normalize\-By\-Weight is on.  
\item {\ttfamily obj.\-Normalize\-By\-Weight\-Off ()} -\/ Setting Normalize\-By\-Weight on will divide the final result by the total weight of the component functions. This process does not otherwise normalize the weighted sum By default, Normalize\-By\-Weight is on.  
\item {\ttfamily double = obj.\-Calculate\-Total\-Weight ()} -\/ Compute the total value of all the weight  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimagewrappad}{}\section{vtk\-Image\-Wrap\-Pad}\label{vtkimaging_vtkimagewrappad}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Wrap\-Pad performs a modulo operation on the output pixel index to determine the source input index. The new image extent of the output has to be specified. Input has to be the same scalar type as output.

To create an instance of class vtk\-Image\-Wrap\-Pad, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageWrapPad
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Wrap\-Pad has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Wrap\-Pad class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Wrap\-Pad = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Wrap\-Pad = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkimplicitfunctiontoimagestencil}{}\section{vtk\-Implicit\-Function\-To\-Image\-Stencil}\label{vtkimaging_vtkimplicitfunctiontoimagestencil}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Implicit\-Function\-To\-Image\-Stencil will convert a vtk\-Implicit\-Function into a stencil that can be used with vtk\-Image\-Stencil or with other classes that apply a stencil to an image.

To create an instance of class vtk\-Implicit\-Function\-To\-Image\-Stencil, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImplicitFunctionToImageStencil
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Implicit\-Function\-To\-Image\-Stencil has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Implicit\-Function\-To\-Image\-Stencil class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Implicit\-Function\-To\-Image\-Stencil = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Implicit\-Function\-To\-Image\-Stencil = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Input (vtk\-Implicit\-Function )} -\/ Specify the implicit function to convert into a stencil.  
\item {\ttfamily vtk\-Implicit\-Function = obj.\-Get\-Input ()} -\/ Specify the implicit function to convert into a stencil.  
\item {\ttfamily obj.\-Set\-Information\-Input (vtk\-Image\-Data )} -\/ Set a vtk\-Image\-Data that has the Spacing, Origin, and Whole\-Extent that will be used for the stencil. This input should be set to the image that you wish to apply the stencil to. If you use this method, then any values set with the Set\-Output\-Spacing, Set\-Output\-Origin, and Set\-Output\-Whole\-Extent methods will be ignored.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Information\-Input ()} -\/ Set a vtk\-Image\-Data that has the Spacing, Origin, and Whole\-Extent that will be used for the stencil. This input should be set to the image that you wish to apply the stencil to. If you use this method, then any values set with the Set\-Output\-Spacing, Set\-Output\-Origin, and Set\-Output\-Whole\-Extent methods will be ignored.  
\item {\ttfamily obj.\-Set\-Output\-Origin (double , double , double )} -\/ Set the Origin to be used for the stencil. It should be set to the Origin of the image you intend to apply the stencil to. The default value is (0,0,0).  
\item {\ttfamily obj.\-Set\-Output\-Origin (double a\mbox{[}3\mbox{]})} -\/ Set the Origin to be used for the stencil. It should be set to the Origin of the image you intend to apply the stencil to. The default value is (0,0,0).  
\item {\ttfamily double = obj. Get\-Output\-Origin ()} -\/ Set the Origin to be used for the stencil. It should be set to the Origin of the image you intend to apply the stencil to. The default value is (0,0,0).  
\item {\ttfamily obj.\-Set\-Output\-Spacing (double , double , double )} -\/ Set the Spacing to be used for the stencil. It should be set to the Spacing of the image you intend to apply the stencil to. The default value is (1,1,1)  
\item {\ttfamily obj.\-Set\-Output\-Spacing (double a\mbox{[}3\mbox{]})} -\/ Set the Spacing to be used for the stencil. It should be set to the Spacing of the image you intend to apply the stencil to. The default value is (1,1,1)  
\item {\ttfamily double = obj. Get\-Output\-Spacing ()} -\/ Set the Spacing to be used for the stencil. It should be set to the Spacing of the image you intend to apply the stencil to. The default value is (1,1,1)  
\item {\ttfamily obj.\-Set\-Output\-Whole\-Extent (int , int , int , int , int , int )} -\/ Set the whole extent for the stencil (anything outside this extent will be considered to be \char`\"{}outside\char`\"{} the stencil). If this is not set, then the stencil will always use the requested Update\-Extent as the stencil extent.  
\item {\ttfamily obj.\-Set\-Output\-Whole\-Extent (int a\mbox{[}6\mbox{]})} -\/ Set the whole extent for the stencil (anything outside this extent will be considered to be \char`\"{}outside\char`\"{} the stencil). If this is not set, then the stencil will always use the requested Update\-Extent as the stencil extent.  
\item {\ttfamily int = obj. Get\-Output\-Whole\-Extent ()} -\/ Set the whole extent for the stencil (anything outside this extent will be considered to be \char`\"{}outside\char`\"{} the stencil). If this is not set, then the stencil will always use the requested Update\-Extent as the stencil extent.  
\item {\ttfamily obj.\-Set\-Threshold (double )} -\/ Set the threshold value for the implicit function.  
\item {\ttfamily double = obj.\-Get\-Threshold ()} -\/ Set the threshold value for the implicit function.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkpointload}{}\section{vtk\-Point\-Load}\label{vtkimaging_vtkpointload}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Point\-Load is a source object that computes stress tensors on a volume. The tensors are computed from the application of a point load on a semi-\/infinite domain. (The analytical results are adapted from Saada -\/ see text.) It also is possible to compute effective stress scalars if desired. This object serves as a specialized data generator for some of the examples in the text.

To create an instance of class vtk\-Point\-Load, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPointLoad
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Point\-Load has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Load class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Point\-Load = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Point\-Load = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Load\-Value (double )} -\/ Set/\-Get value of applied load.  
\item {\ttfamily double = obj.\-Get\-Load\-Value ()} -\/ Set/\-Get value of applied load.  
\item {\ttfamily obj.\-Set\-Sample\-Dimensions (int i, int j, int k)} -\/ Specify the dimensions of the volume. A stress tensor will be computed for each point in the volume.  
\item {\ttfamily obj.\-Set\-Sample\-Dimensions (int dim\mbox{[}3\mbox{]})} -\/ Specify the dimensions of the volume. A stress tensor will be computed for each point in the volume.  
\item {\ttfamily int = obj. Get\-Sample\-Dimensions ()} -\/ Specify the dimensions of the volume. A stress tensor will be computed for each point in the volume.  
\item {\ttfamily obj.\-Set\-Model\-Bounds (double , double , double , double , double , double )} -\/ Specify the region in space over which the tensors are computed. The point load is assumed to be applied at top center of the volume.  
\item {\ttfamily obj.\-Set\-Model\-Bounds (double a\mbox{[}6\mbox{]})} -\/ Specify the region in space over which the tensors are computed. The point load is assumed to be applied at top center of the volume.  
\item {\ttfamily double = obj. Get\-Model\-Bounds ()} -\/ Specify the region in space over which the tensors are computed. The point load is assumed to be applied at top center of the volume.  
\item {\ttfamily obj.\-Set\-Poissons\-Ratio (double )} -\/ Set/\-Get Poisson's ratio.  
\item {\ttfamily double = obj.\-Get\-Poissons\-Ratio ()} -\/ Set/\-Get Poisson's ratio.  
\item {\ttfamily obj.\-Set\-Compute\-Effective\-Stress (int )} -\/ Turn on/off computation of effective stress scalar. These methods do nothing. The effective stress is always computed.  
\item {\ttfamily int = obj.\-Get\-Compute\-Effective\-Stress ()} -\/ Turn on/off computation of effective stress scalar. These methods do nothing. The effective stress is always computed.  
\item {\ttfamily obj.\-Compute\-Effective\-Stress\-On ()} -\/ Turn on/off computation of effective stress scalar. These methods do nothing. The effective stress is always computed.  
\item {\ttfamily obj.\-Compute\-Effective\-Stress\-Off ()} -\/ Turn on/off computation of effective stress scalar. These methods do nothing. The effective stress is always computed.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkrtanalyticsource}{}\section{vtk\-R\-T\-Analytic\-Source}\label{vtkimaging_vtkrtanalyticsource}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-R\-T\-Analytic\-Source just produces images with pixel values determined by a Maximum$\ast$\-Gaussian$\ast$\-X\-Mag$\ast$sin(X\-Freq$\ast$x)$\ast$sin(Y\-Freq$\ast$y)$\ast$cos(Z\-Freq$\ast$z) Values are float scalars on point data with name \char`\"{}\-R\-T\-Data\char`\"{}.

To create an instance of class vtk\-R\-T\-Analytic\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRTAnalyticSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-R\-T\-Analytic\-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\-R\-T\-Analytic\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-R\-T\-Analytic\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-R\-T\-Analytic\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Whole\-Extent (int x\-Minx, int x\-Max, int y\-Min, int y\-Max, int z\-Min, int z\-Max)} -\/ Set/\-Get the extent of the whole output image. Initial value is \{-\/10,10,-\/10,10,-\/10,10\}  
\item {\ttfamily int = obj. Get\-Whole\-Extent ()} -\/ Set/\-Get the extent of the whole output image. Initial value is \{-\/10,10,-\/10,10,-\/10,10\}  
\item {\ttfamily obj.\-Set\-Center (double , double , double )} -\/ Set/\-Get the center of function. Initial value is \{0.\-0,0.\-0,0.\-0\}  
\item {\ttfamily obj.\-Set\-Center (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the center of function. Initial value is \{0.\-0,0.\-0,0.\-0\}  
\item {\ttfamily double = obj. Get\-Center ()} -\/ Set/\-Get the center of function. Initial value is \{0.\-0,0.\-0,0.\-0\}  
\item {\ttfamily obj.\-Set\-Maximum (double )} -\/ Set/\-Get the Maximum value of the function. Initial value is 255.\-0.  
\item {\ttfamily double = obj.\-Get\-Maximum ()} -\/ Set/\-Get the Maximum value of the function. Initial value is 255.\-0.  
\item {\ttfamily obj.\-Set\-Standard\-Deviation (double )} -\/ Set/\-Get the standard deviation of the function. Initial value is 0.\-5.  
\item {\ttfamily double = obj.\-Get\-Standard\-Deviation ()} -\/ Set/\-Get the standard deviation of the function. Initial value is 0.\-5.  
\item {\ttfamily obj.\-Set\-X\-Freq (double )} -\/ Set/\-Get the natural frequency in x. Initial value is 60.  
\item {\ttfamily double = obj.\-Get\-X\-Freq ()} -\/ Set/\-Get the natural frequency in x. Initial value is 60.  
\item {\ttfamily obj.\-Set\-Y\-Freq (double )} -\/ Set/\-Get the natural frequency in y. Initial value is 30.  
\item {\ttfamily double = obj.\-Get\-Y\-Freq ()} -\/ Set/\-Get the natural frequency in y. Initial value is 30.  
\item {\ttfamily obj.\-Set\-Z\-Freq (double )} -\/ Set/\-Get the natural frequency in z. Initial value is 40.  
\item {\ttfamily double = obj.\-Get\-Z\-Freq ()} -\/ Set/\-Get the natural frequency in z. Initial value is 40.  
\item {\ttfamily obj.\-Set\-X\-Mag (double )} -\/ Set/\-Get the magnitude in x. Initial value is 10.  
\item {\ttfamily double = obj.\-Get\-X\-Mag ()} -\/ Set/\-Get the magnitude in x. Initial value is 10.  
\item {\ttfamily obj.\-Set\-Y\-Mag (double )} -\/ Set/\-Get the magnitude in y. Initial value is 18.  
\item {\ttfamily double = obj.\-Get\-Y\-Mag ()} -\/ Set/\-Get the magnitude in y. Initial value is 18.  
\item {\ttfamily obj.\-Set\-Z\-Mag (double )} -\/ Set/\-Get the magnitude in z. Initial value is 5.  
\item {\ttfamily double = obj.\-Get\-Z\-Mag ()} -\/ Set/\-Get the magnitude in z. Initial value is 5.  
\item {\ttfamily obj.\-Set\-Subsample\-Rate (int )} -\/ Set/\-Get the sub-\/sample rate. Initial value is 1.  
\item {\ttfamily int = obj.\-Get\-Subsample\-Rate ()} -\/ Set/\-Get the sub-\/sample rate. Initial value is 1.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtksamplefunction}{}\section{vtk\-Sample\-Function}\label{vtkimaging_vtksamplefunction}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Sample\-Function is a source object that evaluates an implicit function and normals at each point in a vtk\-Structured\-Points. The user can specify the sample dimensions and location in space to perform the sampling. To create closed surfaces (in conjunction with the vtk\-Contour\-Filter), capping can be turned on to set a particular value on the boundaries of the sample space.

To create an instance of class vtk\-Sample\-Function, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSampleFunction
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-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\-Sample\-Function class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Sample\-Function = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Sample\-Function = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\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 ()} -\/ Control the type of the scalars object by explicitly providing a scalar object. T\-H\-I\-S I\-S D\-E\-P\-R\-E\-C\-A\-T\-E\-D, although it still works!!! Please use Set\-Output\-Scalar\-Type instead.  
\item {\ttfamily obj.\-Set\-Scalars (vtk\-Data\-Array da)} -\/ Control the type of the scalars object by explicitly providing a scalar object. T\-H\-I\-S I\-S D\-E\-P\-R\-E\-C\-A\-T\-E\-D, although it still works!!! Please use Set\-Output\-Scalar\-Type instead.  
\item {\ttfamily obj.\-Set\-Sample\-Dimensions (int i, int j, int k)} -\/ Specify the dimensions of the data on which to sample.  
\item {\ttfamily obj.\-Set\-Sample\-Dimensions (int dim\mbox{[}3\mbox{]})} -\/ Specify the dimensions of the data on which to sample.  
\item {\ttfamily int = obj. Get\-Sample\-Dimensions ()} -\/ Specify the dimensions of the data on which to sample.  
\item {\ttfamily obj.\-Set\-Model\-Bounds (double , double , double , double , double , double )} -\/ Specify the region in space over which the sampling occurs. The bounds is specified as (x\-Min,x\-Max, y\-Min,y\-Max, z\-Min,z\-Max).  
\item {\ttfamily obj.\-Set\-Model\-Bounds (double a\mbox{[}6\mbox{]})} -\/ Specify the region in space over which the sampling occurs. The bounds is specified as (x\-Min,x\-Max, y\-Min,y\-Max, z\-Min,z\-Max).  
\item {\ttfamily double = obj. Get\-Model\-Bounds ()} -\/ Specify the region in space over which the sampling occurs. The bounds is specified as (x\-Min,x\-Max, y\-Min,y\-Max, z\-Min,z\-Max).  
\item {\ttfamily obj.\-Set\-Capping (int )} -\/ Turn on/off capping. If capping is on, then the outer boundaries of the structured point set are set to cap value. This can be used to insure surfaces are closed.  
\item {\ttfamily int = obj.\-Get\-Capping ()} -\/ Turn on/off capping. If capping is on, then the outer boundaries of the structured point set are set to cap value. This can be used to insure surfaces are closed.  
\item {\ttfamily obj.\-Capping\-On ()} -\/ Turn on/off capping. If capping is on, then the outer boundaries of the structured point set are set to cap value. This can be used to insure surfaces are closed.  
\item {\ttfamily obj.\-Capping\-Off ()} -\/ Turn on/off capping. If capping is on, then the outer boundaries of the structured point set are set to cap value. This can be used to insure surfaces are closed.  
\item {\ttfamily obj.\-Set\-Cap\-Value (double )} -\/ Set the cap value.  
\item {\ttfamily double = obj.\-Get\-Cap\-Value ()} -\/ Set the cap value.  
\item {\ttfamily obj.\-Set\-Compute\-Normals (int )} -\/ Turn on/off the computation of normals (normals are float values).  
\item {\ttfamily int = obj.\-Get\-Compute\-Normals ()} -\/ Turn on/off the computation of normals (normals are float values).  
\item {\ttfamily obj.\-Compute\-Normals\-On ()} -\/ Turn on/off the computation of normals (normals are float values).  
\item {\ttfamily obj.\-Compute\-Normals\-Off ()} -\/ Turn on/off the computation of normals (normals are float values).  
\item {\ttfamily obj.\-Set\-Scalar\-Array\-Name (string )} -\/ Set/get the scalar array name for this data set. Initial value is \char`\"{}scalars\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-Scalar\-Array\-Name ()} -\/ Set/get the scalar array name for this data set. Initial value is \char`\"{}scalars\char`\"{}.  
\item {\ttfamily obj.\-Set\-Normal\-Array\-Name (string )} -\/ Set/get the normal array name for this data set. Initial value is \char`\"{}normals\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-Normal\-Array\-Name ()} -\/ Set/get the normal array name for this data set. Initial value is \char`\"{}normals\char`\"{}.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return the M\-Time also considering the implicit function.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkshepardmethod}{}\section{vtk\-Shepard\-Method}\label{vtkimaging_vtkshepardmethod}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Shepard\-Method is a filter used to visualize unstructured point data using Shepard's method. The method works by resampling the unstructured points onto a structured points set. The influence functions are described as \char`\"{}inverse distance weighted\char`\"{}. Once the structured points are computed, the usual visualization techniques (e.\-g., iso-\/contouring or volume rendering) can be used visualize the structured points.

To create an instance of class vtk\-Shepard\-Method, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkShepardMethod
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Shepard\-Method has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Shepard\-Method class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Shepard\-Method = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Shepard\-Method = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily double = obj.\-Compute\-Model\-Bounds (double origin\mbox{[}3\mbox{]}, double ar\mbox{[}3\mbox{]})} -\/ Compute Model\-Bounds from input geometry.  
\item {\ttfamily int = obj. Get\-Sample\-Dimensions ()} -\/ Specify i-\/j-\/k dimensions on which to sample input points.  
\item {\ttfamily obj.\-Set\-Sample\-Dimensions (int i, int j, int k)} -\/ Set the i-\/j-\/k dimensions on which to sample the distance function.  
\item {\ttfamily obj.\-Set\-Sample\-Dimensions (int dim\mbox{[}3\mbox{]})} -\/ Set the i-\/j-\/k dimensions on which to sample the distance function.  
\item {\ttfamily obj.\-Set\-Maximum\-Distance (double )} -\/ Specify influence distance of each input point. This distance is a fraction of the length of the diagonal of the sample space. Thus, values of 1.\-0 will cause each input point to influence all points in the structured point dataset. Values less than 1.\-0 can improve performance significantly.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Distance\-Min\-Value ()} -\/ Specify influence distance of each input point. This distance is a fraction of the length of the diagonal of the sample space. Thus, values of 1.\-0 will cause each input point to influence all points in the structured point dataset. Values less than 1.\-0 can improve performance significantly.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Distance\-Max\-Value ()} -\/ Specify influence distance of each input point. This distance is a fraction of the length of the diagonal of the sample space. Thus, values of 1.\-0 will cause each input point to influence all points in the structured point dataset. Values less than 1.\-0 can improve performance significantly.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Distance ()} -\/ Specify influence distance of each input point. This distance is a fraction of the length of the diagonal of the sample space. Thus, values of 1.\-0 will cause each input point to influence all points in the structured point dataset. Values less than 1.\-0 can improve performance significantly.  
\item {\ttfamily obj.\-Set\-Model\-Bounds (double , double , double , double , double , double )} -\/ Specify the position in space to perform the sampling.  
\item {\ttfamily obj.\-Set\-Model\-Bounds (double a\mbox{[}6\mbox{]})} -\/ Specify the position in space to perform the sampling.  
\item {\ttfamily double = obj. Get\-Model\-Bounds ()} -\/ Specify the position in space to perform the sampling.  
\item {\ttfamily obj.\-Set\-Null\-Value (double )} -\/ Set the Null value for output points not receiving a contribution from the input points.  
\item {\ttfamily double = obj.\-Get\-Null\-Value ()} -\/ Set the Null value for output points not receiving a contribution from the input points.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtksimpleimagefilterexample}{}\section{vtk\-Simple\-Image\-Filter\-Example}\label{vtkimaging_vtksimpleimagefilterexample}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is an example of a simple image-\/image filter. It copies it's input to it's output (point by point). It shows how templates can be used to support various data types. .S\-E\-C\-T\-I\-O\-N See also vtk\-Simple\-Image\-To\-Image\-Filter

To create an instance of class vtk\-Simple\-Image\-Filter\-Example, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSimpleImageFilterExample
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Simple\-Image\-Filter\-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\-Simple\-Image\-Filter\-Example class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Simple\-Image\-Filter\-Example = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Simple\-Image\-Filter\-Example = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkimaging_vtksurfacereconstructionfilter}{}\section{vtk\-Surface\-Reconstruction\-Filter}\label{vtkimaging_vtksurfacereconstructionfilter}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Surface\-Reconstruction\-Filter takes a list of points assumed to lie on the surface of a solid 3\-D object. A signed measure of the distance to the surface is computed and sampled on a regular grid. The grid can then be contoured at zero to extract the surface. The default values for neighborhood size and sample spacing should give reasonable results for most uses but can be set if desired. This procedure is based on the Ph\-D work of Hugues Hoppe\-: \href{http://www.research.microsoft.com/~hoppe}{\tt http\-://www.\-research.\-microsoft.\-com/$\sim$hoppe}

To create an instance of class vtk\-Surface\-Reconstruction\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSurfaceReconstructionFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Surface\-Reconstruction\-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\-Surface\-Reconstruction\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Surface\-Reconstruction\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Surface\-Reconstruction\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Neighborhood\-Size ()} -\/ Specify the number of neighbors each point has, used for estimating the local surface orientation. The default value of 20 should be O\-K for most applications, higher values can be specified if the spread of points is uneven. Values as low as 10 may yield adequate results for some surfaces. Higher values cause the algorithm to take longer. Higher values will cause errors on sharp boundaries.  
\item {\ttfamily obj.\-Set\-Neighborhood\-Size (int )} -\/ Specify the number of neighbors each point has, used for estimating the local surface orientation. The default value of 20 should be O\-K for most applications, higher values can be specified if the spread of points is uneven. Values as low as 10 may yield adequate results for some surfaces. Higher values cause the algorithm to take longer. Higher values will cause errors on sharp boundaries.  
\item {\ttfamily double = obj.\-Get\-Sample\-Spacing ()} -\/ Specify the spacing of the 3\-D sampling grid. If not set, a reasonable guess will be made.  
\item {\ttfamily obj.\-Set\-Sample\-Spacing (double )} -\/ Specify the spacing of the 3\-D sampling grid. If not set, a reasonable guess will be made.  
\end{DoxyItemize}\hypertarget{vtkimaging_vtktriangulartexture}{}\section{vtk\-Triangular\-Texture}\label{vtkimaging_vtktriangulartexture}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Triangular\-Texture is a filter that generates a 2\-D texture map based on the paper \char`\"{}\-Opacity-\/modulating Triangular Textures for Irregular Surfaces,\char`\"{} by Penny Rheingans, I\-E\-E\-E Visualization '96, pp. 219-\/225. The textures assume texture coordinates of (0,0), (1.\-0) and (.5, sqrt(3)/2). The sequence of texture values is the same along each edge of the triangular texture map. So, the assignment order of texture coordinates is arbitrary.

To create an instance of class vtk\-Triangular\-Texture, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTriangularTexture
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Triangular\-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\-Triangular\-Texture class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Triangular\-Texture = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Triangular\-Texture = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Scale\-Factor (double )} -\/ Set a Scale Factor.  
\item {\ttfamily double = obj.\-Get\-Scale\-Factor ()} -\/ Set a Scale Factor.  
\item {\ttfamily obj.\-Set\-X\-Size (int )} -\/ Set the X texture map dimension. Default is 64.  
\item {\ttfamily int = obj.\-Get\-X\-Size ()} -\/ Set the X texture map dimension. Default is 64.  
\item {\ttfamily obj.\-Set\-Y\-Size (int )} -\/ Set the Y texture map dimension. Default is 64.  
\item {\ttfamily int = obj.\-Get\-Y\-Size ()} -\/ Set the Y texture map dimension. Default is 64.  
\item {\ttfamily obj.\-Set\-Texture\-Pattern (int )} -\/ Set the texture pattern. 1 = opaque at centroid (default) 2 = opaque at vertices 3 = opaque in rings around vertices  
\item {\ttfamily int = obj.\-Get\-Texture\-Pattern\-Min\-Value ()} -\/ Set the texture pattern. 1 = opaque at centroid (default) 2 = opaque at vertices 3 = opaque in rings around vertices  
\item {\ttfamily int = obj.\-Get\-Texture\-Pattern\-Max\-Value ()} -\/ Set the texture pattern. 1 = opaque at centroid (default) 2 = opaque at vertices 3 = opaque in rings around vertices  
\item {\ttfamily int = obj.\-Get\-Texture\-Pattern ()} -\/ Set the texture pattern. 1 = opaque at centroid (default) 2 = opaque at vertices 3 = opaque in rings around vertices  
\end{DoxyItemize}\hypertarget{vtkimaging_vtkvoxelmodeller}{}\section{vtk\-Voxel\-Modeller}\label{vtkimaging_vtkvoxelmodeller}
Section\-: \hyperlink{sec_vtkimaging}{Visualization Toolkit Imaging Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Voxel\-Modeller is a filter that converts an arbitrary data set to a structured point (i.\-e., voxel) representation. It is very similar to vtk\-Implicit\-Modeller, except that it doesn't record distance; instead it records occupancy. By default it supports a compact output of 0/1 V\-T\-K\-\_\-\-B\-I\-T. Other vtk scalar types can be specified. The Foreground and Background values of the output can also be specified. N\-O\-T\-E\-: Not all vtk filters/readers/writers support the V\-T\-K\-\_\-\-B\-I\-T scalar type. You may want to use V\-T\-K\-\_\-\-C\-H\-A\-R as an alternative.

To create an instance of class vtk\-Voxel\-Modeller, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVoxelModeller
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Voxel\-Modeller has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Modeller class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Voxel\-Modeller = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Voxel\-Modeller = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily double = obj.\-Compute\-Model\-Bounds (double origin\mbox{[}3\mbox{]}, double ar\mbox{[}3\mbox{]})} -\/ Compute the Model\-Bounds based on the input geometry.  
\item {\ttfamily obj.\-Set\-Sample\-Dimensions (int i, int j, int k)} -\/ Set the i-\/j-\/k dimensions on which to sample the distance function. Default is (50, 50, 50)  
\item {\ttfamily obj.\-Set\-Sample\-Dimensions (int dim\mbox{[}3\mbox{]})} -\/ Set the i-\/j-\/k dimensions on which to sample the distance function. Default is (50, 50, 50)  
\item {\ttfamily int = obj. Get\-Sample\-Dimensions ()} -\/ Set the i-\/j-\/k dimensions on which to sample the distance function. Default is (50, 50, 50)  
\item {\ttfamily obj.\-Set\-Maximum\-Distance (double )} -\/ Specify distance away from surface of input geometry to sample. Smaller values make large increases in performance. Default is 1.\-0.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Distance\-Min\-Value ()} -\/ Specify distance away from surface of input geometry to sample. Smaller values make large increases in performance. Default is 1.\-0.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Distance\-Max\-Value ()} -\/ Specify distance away from surface of input geometry to sample. Smaller values make large increases in performance. Default is 1.\-0.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Distance ()} -\/ Specify distance away from surface of input geometry to sample. Smaller values make large increases in performance. Default is 1.\-0.  
\item {\ttfamily obj.\-Set\-Model\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Specify the position in space to perform the voxelization. Default is (0, 0, 0, 0, 0, 0)  
\item {\ttfamily obj.\-Set\-Model\-Bounds (double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)} -\/ Specify the position in space to perform the voxelization. Default is (0, 0, 0, 0, 0, 0)  
\item {\ttfamily double = obj. Get\-Model\-Bounds ()} -\/ Specify the position in space to perform the voxelization. Default is (0, 0, 0, 0, 0, 0)  
\item {\ttfamily obj.\-Set\-Scalar\-Type (int )} -\/ Control the scalar type of the output image. The default is V\-T\-K\-\_\-\-B\-I\-T. N\-O\-T\-E\-: Not all filters/readers/writers support the V\-T\-K\-\_\-\-B\-I\-T scalar type. You may want to use V\-T\-K\-\_\-\-C\-H\-A\-R as an alternative.  
\item {\ttfamily obj.\-Set\-Scalar\-Type\-To\-Float ()} -\/ Control the scalar type of the output image. The default is V\-T\-K\-\_\-\-B\-I\-T. N\-O\-T\-E\-: Not all filters/readers/writers support the V\-T\-K\-\_\-\-B\-I\-T scalar type. You may want to use V\-T\-K\-\_\-\-C\-H\-A\-R as an alternative.  
\item {\ttfamily obj.\-Set\-Scalar\-Type\-To\-Double ()} -\/ Control the scalar type of the output image. The default is V\-T\-K\-\_\-\-B\-I\-T. N\-O\-T\-E\-: Not all filters/readers/writers support the V\-T\-K\-\_\-\-B\-I\-T scalar type. You may want to use V\-T\-K\-\_\-\-C\-H\-A\-R as an alternative.  
\item {\ttfamily obj.\-Set\-Scalar\-Type\-To\-Int ()} -\/ Control the scalar type of the output image. The default is V\-T\-K\-\_\-\-B\-I\-T. N\-O\-T\-E\-: Not all filters/readers/writers support the V\-T\-K\-\_\-\-B\-I\-T scalar type. You may want to use V\-T\-K\-\_\-\-C\-H\-A\-R as an alternative.  
\item {\ttfamily obj.\-Set\-Scalar\-Type\-To\-Unsigned\-Int ()} -\/ Control the scalar type of the output image. The default is V\-T\-K\-\_\-\-B\-I\-T. N\-O\-T\-E\-: Not all filters/readers/writers support the V\-T\-K\-\_\-\-B\-I\-T scalar type. You may want to use V\-T\-K\-\_\-\-C\-H\-A\-R as an alternative.  
\item {\ttfamily obj.\-Set\-Scalar\-Type\-To\-Long ()} -\/ Control the scalar type of the output image. The default is V\-T\-K\-\_\-\-B\-I\-T. N\-O\-T\-E\-: Not all filters/readers/writers support the V\-T\-K\-\_\-\-B\-I\-T scalar type. You may want to use V\-T\-K\-\_\-\-C\-H\-A\-R as an alternative.  
\item {\ttfamily obj.\-Set\-Scalar\-Type\-To\-Unsigned\-Long ()} -\/ Control the scalar type of the output image. The default is V\-T\-K\-\_\-\-B\-I\-T. N\-O\-T\-E\-: Not all filters/readers/writers support the V\-T\-K\-\_\-\-B\-I\-T scalar type. You may want to use V\-T\-K\-\_\-\-C\-H\-A\-R as an alternative.  
\item {\ttfamily obj.\-Set\-Scalar\-Type\-To\-Short ()} -\/ Control the scalar type of the output image. The default is V\-T\-K\-\_\-\-B\-I\-T. N\-O\-T\-E\-: Not all filters/readers/writers support the V\-T\-K\-\_\-\-B\-I\-T scalar type. You may want to use V\-T\-K\-\_\-\-C\-H\-A\-R as an alternative.  
\item {\ttfamily obj.\-Set\-Scalar\-Type\-To\-Unsigned\-Short ()} -\/ Control the scalar type of the output image. The default is V\-T\-K\-\_\-\-B\-I\-T. N\-O\-T\-E\-: Not all filters/readers/writers support the V\-T\-K\-\_\-\-B\-I\-T scalar type. You may want to use V\-T\-K\-\_\-\-C\-H\-A\-R as an alternative.  
\item {\ttfamily obj.\-Set\-Scalar\-Type\-To\-Unsigned\-Char ()} -\/ Control the scalar type of the output image. The default is V\-T\-K\-\_\-\-B\-I\-T. N\-O\-T\-E\-: Not all filters/readers/writers support the V\-T\-K\-\_\-\-B\-I\-T scalar type. You may want to use V\-T\-K\-\_\-\-C\-H\-A\-R as an alternative.  
\item {\ttfamily obj.\-Set\-Scalar\-Type\-To\-Char ()} -\/ Control the scalar type of the output image. The default is V\-T\-K\-\_\-\-B\-I\-T. N\-O\-T\-E\-: Not all filters/readers/writers support the V\-T\-K\-\_\-\-B\-I\-T scalar type. You may want to use V\-T\-K\-\_\-\-C\-H\-A\-R as an alternative.  
\item {\ttfamily obj.\-Set\-Scalar\-Type\-To\-Bit ()} -\/ Control the scalar type of the output image. The default is V\-T\-K\-\_\-\-B\-I\-T. N\-O\-T\-E\-: Not all filters/readers/writers support the V\-T\-K\-\_\-\-B\-I\-T scalar type. You may want to use V\-T\-K\-\_\-\-C\-H\-A\-R as an alternative.  
\item {\ttfamily int = obj.\-Get\-Scalar\-Type ()} -\/ Control the scalar type of the output image. The default is V\-T\-K\-\_\-\-B\-I\-T. N\-O\-T\-E\-: Not all filters/readers/writers support the V\-T\-K\-\_\-\-B\-I\-T scalar type. You may want to use V\-T\-K\-\_\-\-C\-H\-A\-R as an alternative.  
\item {\ttfamily obj.\-Set\-Foreground\-Value (double )} -\/ Set the Foreground/\-Background values of the output. The Foreground value is set when a voxel is occupied. The Background value is set when a voxel is not occupied. The default Foreground\-Value is 1. The default Background\-Value is 0.  
\item {\ttfamily double = obj.\-Get\-Foreground\-Value ()} -\/ Set the Foreground/\-Background values of the output. The Foreground value is set when a voxel is occupied. The Background value is set when a voxel is not occupied. The default Foreground\-Value is 1. The default Background\-Value is 0.  
\item {\ttfamily obj.\-Set\-Background\-Value (double )} -\/ Set the Foreground/\-Background values of the output. The Foreground value is set when a voxel is occupied. The Background value is set when a voxel is not occupied. The default Foreground\-Value is 1. The default Background\-Value is 0.  
\item {\ttfamily double = obj.\-Get\-Background\-Value ()} -\/ Set the Foreground/\-Background values of the output. The Foreground value is set when a voxel is occupied. The Background value is set when a voxel is not occupied. The default Foreground\-Value is 1. The default Background\-Value is 0.  
\end{DoxyItemize}