"""
This type stub file was generated by pyright.
"""

import vtkmodules.vtkCommonExecutionModel as __vtkmodules_vtkCommonExecutionModel

class vtkImageReslice(__vtkmodules_vtkCommonExecutionModel.vtkThreadedImageAlgorithm):
    """
    vtkImageReslice - Reslices a volume along a new set of axes.
    
    Superclass: vtkThreadedImageAlgorithm
    
    vtkImageReslice 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 vtkImagePermute,
    vtkImageResample, and vtkImagePad filters.  There are a number of
    tasks that vtkImageReslice is well suited for:
    
    1) Application of simple rotations, scales, and translations to an
    image. It is often a good idea to use vtkImageChangeInformation 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 SetInformationInput() 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
    SetResliceTransform 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 SetResliceAxesDirectionCosines() to specify
    the orientation of the slice.  The direction cosines give the x, y,
    and z axes for the output volume.  The method
    SetOutputDimensionality(2) is used to specify that want to output a
    slice rather than a volume.  The SetResliceAxesOrigin() command is
    used to provide an (x,y,z) point that the slice will pass through.
    You can use both the ResliceAxes and the ResliceTransform at the same
    time, in order to extract slices from a volume that you have applied
    a transformation to.
    @warning
    This filter is very inefficient if the output X dimension is 1.
    @sa
    vtkAbstractTransform vtkMatrix4x4
    """
    def AutoCropOutputOff(self):
        """
        V.AutoCropOutputOff()
        C++: virtual void AutoCropOutputOff()
        
        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).
        """
        ...
    
    def AutoCropOutputOn(self):
        """
        V.AutoCropOutputOn()
        C++: virtual void AutoCropOutputOn()
        
        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).
        """
        ...
    
    def BorderOff(self):
        """
        V.BorderOff()
        C++: virtual void BorderOff()
        
        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.
        """
        ...
    
    def BorderOn(self):
        """
        V.BorderOn()
        C++: virtual void BorderOn()
        
        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.
        """
        ...
    
    def GenerateStencilOutputOff(self):
        """
        V.GenerateStencilOutputOff()
        C++: virtual void GenerateStencilOutputOff()
        
        Generate an output stencil that defines which pixels were
        interpolated and which pixels were out-of-bounds of the input.
        """
        ...
    
    def GenerateStencilOutputOn(self):
        """
        V.GenerateStencilOutputOn()
        C++: virtual void GenerateStencilOutputOn()
        
        Generate an output stencil that defines which pixels were
        interpolated and which pixels were out-of-bounds of the input.
        """
        ...
    
    def GetAutoCropOutput(self):
        """
        V.GetAutoCropOutput() -> int
        C++: virtual vtkTypeBool GetAutoCropOutput()
        
        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).
        """
        ...
    
    def GetBackgroundColor(self):
        """
        V.GetBackgroundColor() -> (float, float, float, float)
        C++: virtual double *GetBackgroundColor()
        
        Set the background color (for multi-component images).
        """
        ...
    
    def GetBackgroundLevel(self):
        """
        V.GetBackgroundLevel() -> float
        C++: double GetBackgroundLevel()
        
        Set background grey level (for single-component images).
        """
        ...
    
    def GetBorder(self):
        """
        V.GetBorder() -> int
        C++: virtual vtkTypeBool GetBorder()
        
        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.
        """
        ...
    
    def GetBorderThickness(self):
        """
        V.GetBorderThickness() -> float
        C++: virtual double GetBorderThickness()
        """
        ...
    
    def GetGenerateStencilOutput(self):
        """
        V.GetGenerateStencilOutput() -> int
        C++: virtual vtkTypeBool GetGenerateStencilOutput()
        
        Generate an output stencil that defines which pixels were
        interpolated and which pixels were out-of-bounds of the input.
        """
        ...
    
    def GetInformationInput(self):
        """
        V.GetInformationInput() -> vtkImageData
        C++: virtual vtkImageData *GetInformationInput()
        
        Set a vtkImageData from which the default Spacing, Origin, and
        WholeExtent of the output will be copied.  The spacing, origin,
        and extent will be permuted according to the ResliceAxes.  Any
        values set via SetOutputSpacing, SetOutputOrigin, and
        SetOutputExtent will override these values.  By default, the
        Spacing, Origin, and WholeExtent of the Input are used.
        """
        ...
    
    def GetInterpolate(self):
        """
        V.GetInterpolate() -> int
        C++: int GetInterpolate()
        
        Convenient methods for switching between nearest-neighbor and
        linear interpolation. InterpolateOn() is equivalent to
        SetInterpolationModeToLinear() and InterpolateOff() is equivalent
        to SetInterpolationModeToNearestNeighbor() You should not use
        these methods if you use the SetInterpolationMode methods.
        """
        ...
    
    def GetInterpolationMode(self):
        """
        V.GetInterpolationMode() -> int
        C++: virtual int GetInterpolationMode()
        """
        ...
    
    def GetInterpolationModeAsString(self):
        """
        V.GetInterpolationModeAsString() -> string
        C++: virtual const char *GetInterpolationModeAsString()
        """
        ...
    
    def GetInterpolationModeMaxValue(self):
        """
        V.GetInterpolationModeMaxValue() -> int
        C++: virtual int GetInterpolationModeMaxValue()
        """
        ...
    
    def GetInterpolationModeMinValue(self):
        """
        V.GetInterpolationModeMinValue() -> int
        C++: virtual int GetInterpolationModeMinValue()
        """
        ...
    
    def GetInterpolator(self):
        """
        V.GetInterpolator() -> vtkAbstractImageInterpolator
        C++: virtual vtkAbstractImageInterpolator *GetInterpolator()
        
        Set the interpolator to use.  The default interpolator supports
        the Nearest, Linear, and Cubic interpolation modes.
        """
        ...
    
    def GetMirror(self):
        """
        V.GetMirror() -> int
        C++: virtual vtkTypeBool GetMirror()
        
        Turn on mirror-pad feature (default: Off). This will override the
        wrap-pad.
        """
        ...
    
    def GetMTime(self):
        """
        V.GetMTime() -> int
        C++: vtkMTimeType GetMTime() override;
        
        When determining the modified time of the filter, this check the
        modified time of the transform and matrix.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetOptimization(self):
        """
        V.GetOptimization() -> int
        C++: virtual vtkTypeBool GetOptimization()
        
        Turn on and off optimizations (default on, they should only be
        turned off for testing purposes).
        """
        ...
    
    def GetOutputDimensionality(self):
        """
        V.GetOutputDimensionality() -> int
        C++: virtual int GetOutputDimensionality()
        
        Force the dimensionality of the output to either 1, 2, 3 or 0
        (default: 3).  If the dimensionality is 2D, 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 1D, the output extent is
        confined to the x axis. For 0D, the output extent consists of a
        single voxel at (0,0,0).
        """
        ...
    
    def GetOutputExtent(self):
        """
        V.GetOutputExtent() -> (int, int, int, int, int, int)
        C++: virtual int *GetOutputExtent()
        
        Set the extent for the output data.  The default output extent is
        the input extent permuted through the ResliceAxes.
        """
        ...
    
    def GetOutputOrigin(self):
        """
        V.GetOutputOrigin() -> (float, float, float)
        C++: virtual double *GetOutputOrigin()
        
        Set the origin for the output data.  The default output origin is
        the input origin permuted through the ResliceAxes.
        """
        ...
    
    def GetOutputScalarType(self):
        """
        V.GetOutputScalarType() -> int
        C++: virtual int GetOutputScalarType()
        
        Set the scalar type of the output to be different from the input.
        The default value is -1, which means that the input scalar type
        will be used to set the output scalar type.  Otherwise, this must
        be set to one of the following types: VTK_CHAR, VTK_SIGNED_CHAR,
        VTK_UNSIGNED_CHAR, VTK_SHORT, VTK_UNSIGNED_SHORT, VTK_INT,
        VTK_UNSIGNED_INT, VTK_FLOAT, or VTK_DOUBLE.  Other types are not
        permitted.  If the output type is an integer type, the output
        will be rounded and clamped to the limits of the type.
        """
        ...
    
    def GetOutputSpacing(self):
        """
        V.GetOutputSpacing() -> (float, float, float)
        C++: virtual double *GetOutputSpacing()
        
        Set the voxel spacing for the output data.  The default output
        spacing is the input spacing permuted through the ResliceAxes.
        """
        ...
    
    def GetResliceAxes(self):
        """
        V.GetResliceAxes() -> vtkMatrix4x4
        C++: virtual vtkMatrix4x4 *GetResliceAxes()
        
        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
        ResliceAxes are used most often to permute the data, e.g. to
        extract ZY or XZ slices of a volume as 2D XY 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 SetResliceAxes() is to use
        SetResliceAxesDirectionCosines() to set the directions of the
        axes and SetResliceAxesOrigin() to set the origin of the axes.
        """
        ...
    
    def GetResliceAxesDirectionCosines(self, p_float=..., p_float=..., p_float=..., *args, **kwargs):
        """
        V.GetResliceAxesDirectionCosines([float, float, float], [float,
            float, float], [float, float, float])
        C++: void GetResliceAxesDirectionCosines(double x[3], double y[3],
             double z[3])
        V.GetResliceAxesDirectionCosines([float, float, float, float,
            float, float, float, float, float])
        C++: void GetResliceAxesDirectionCosines(double xyz[9])
        V.GetResliceAxesDirectionCosines() -> (float, float, float, float,
             float, float, float, float, float)
        C++: double *GetResliceAxesDirectionCosines()
        
        Specify the direction cosines for the ResliceAxes (i.e. the first
        three elements of each of the first three columns of the
        ResliceAxes matrix).  This will modify the current ResliceAxes
        matrix, or create a new matrix if none exists.
        """
        ...
    
    def GetResliceAxesOrigin(self, p_float=..., p_float=..., p_float=...):
        """
        V.GetResliceAxesOrigin([float, float, float])
        C++: void GetResliceAxesOrigin(double xyz[3])
        V.GetResliceAxesOrigin() -> (float, float, float)
        C++: double *GetResliceAxesOrigin()
        
        Specify the origin for the ResliceAxes (i.e. the first three
        elements of the final column of the ResliceAxes matrix). This
        will modify the current ResliceAxes matrix, or create new matrix
        if none exists.
        """
        ...
    
    def GetResliceTransform(self):
        """
        V.GetResliceTransform() -> vtkAbstractTransform
        C++: virtual vtkAbstractTransform *GetResliceTransform()
        
        Set a transform to be applied to the resampling grid that has
        been defined via the ResliceAxes 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 vtkGridTransform and
        vtkThinPlateSplineTransform can be used here.
        """
        ...
    
    def GetScalarScale(self):
        """
        V.GetScalarScale() -> float
        C++: virtual double GetScalarScale()
        
        Set multiplication factor to apply to all the output voxels.
        After a sample value has been interpolated from the input image,
        the equation u = (v + ScalarShift)*ScalarScale will be applied to
        it before it is written to the output image.  The result will
        always be clamped to the limits of the output data type.
        """
        ...
    
    def GetScalarShift(self):
        """
        V.GetScalarShift() -> float
        C++: virtual double GetScalarShift()
        
        Set a value to add to all the output voxels. After a sample value
        has been interpolated from the input image, the equation u = (v +
        ScalarShift)*ScalarScale will be applied to it before it is
        written to the output image.  The result will always be clamped
        to the limits of the output data type.
        """
        ...
    
    def GetSlabMode(self):
        """
        V.GetSlabMode() -> int
        C++: virtual int GetSlabMode()
        
        Set the slab mode, for generating thick slices. The default is
        Mean. If SetSlabNumberOfSlices(N) is called with N greater than
        one, then each output slice will actually be a composite of N
        slices.  This method specifies the compositing mode to be used.
        """
        ...
    
    def GetSlabModeAsString(self):
        """
        V.GetSlabModeAsString() -> string
        C++: virtual const char *GetSlabModeAsString()
        
        Set the slab mode, for generating thick slices. The default is
        Mean. If SetSlabNumberOfSlices(N) is called with N greater than
        one, then each output slice will actually be a composite of N
        slices.  This method specifies the compositing mode to be used.
        """
        ...
    
    def GetSlabModeMaxValue(self):
        """
        V.GetSlabModeMaxValue() -> int
        C++: virtual int GetSlabModeMaxValue()
        
        Set the slab mode, for generating thick slices. The default is
        Mean. If SetSlabNumberOfSlices(N) is called with N greater than
        one, then each output slice will actually be a composite of N
        slices.  This method specifies the compositing mode to be used.
        """
        ...
    
    def GetSlabModeMinValue(self):
        """
        V.GetSlabModeMinValue() -> int
        C++: virtual int GetSlabModeMinValue()
        
        Set the slab mode, for generating thick slices. The default is
        Mean. If SetSlabNumberOfSlices(N) is called with N greater than
        one, then each output slice will actually be a composite of N
        slices.  This method specifies the compositing mode to be used.
        """
        ...
    
    def GetSlabNumberOfSlices(self):
        """
        V.GetSlabNumberOfSlices() -> int
        C++: virtual int GetSlabNumberOfSlices()
        
        Set the number of slices that will be combined to create the
        slab.
        """
        ...
    
    def GetSlabSliceSpacingFraction(self):
        """
        V.GetSlabSliceSpacingFraction() -> float
        C++: virtual double GetSlabSliceSpacingFraction()
        
        The slab spacing as a fraction of the output slice spacing. When
        one of the various slab modes is chosen, each output slice is
        produced by generating several "temporary" output slices and then
        combining them according to the slab mode.  By default, the
        spacing between these temporary slices is the Z component of the
        OutputSpacing. This method sets the spacing between these
        temporary slices to be a fraction of the output spacing.
        """
        ...
    
    def GetSlabTrapezoidIntegration(self):
        """
        V.GetSlabTrapezoidIntegration() -> int
        C++: virtual vtkTypeBool GetSlabTrapezoidIntegration()
        
        Use trapezoid integration for slab computation.  All this does is
        weigh the first and last slices by half when doing sum and mean.
        It is off by default.
        """
        ...
    
    def GetStencil(self):
        """
        V.GetStencil() -> vtkImageStencilData
        C++: vtkImageStencilData *GetStencil()
        
        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.
        """
        ...
    
    def GetStencilOutput(self):
        """
        V.GetStencilOutput() -> vtkImageStencilData
        C++: vtkImageStencilData *GetStencilOutput()
        
        Get the output stencil.
        """
        ...
    
    def GetStencilOutputPort(self):
        """
        V.GetStencilOutputPort() -> vtkAlgorithmOutput
        C++: vtkAlgorithmOutput *GetStencilOutputPort()
        
        Get the output stencil.
        """
        ...
    
    def GetTransformInputSampling(self):
        """
        V.GetTransformInputSampling() -> int
        C++: virtual vtkTypeBool GetTransformInputSampling()
        
        Specify whether to transform the spacing, origin and extent of
        the Input (or the InformationInput) according to the direction
        cosines and origin of the ResliceAxes before applying them as the
        default output spacing, origin and extent (default: On).
        """
        ...
    
    def GetWrap(self):
        """
        V.GetWrap() -> int
        C++: virtual vtkTypeBool GetWrap()
        
        Turn on wrap-pad feature (default: Off).
        """
        ...
    
    def InterpolateOff(self):
        """
        V.InterpolateOff()
        C++: void InterpolateOff()
        
        Convenient methods for switching between nearest-neighbor and
        linear interpolation. InterpolateOn() is equivalent to
        SetInterpolationModeToLinear() and InterpolateOff() is equivalent
        to SetInterpolationModeToNearestNeighbor() You should not use
        these methods if you use the SetInterpolationMode methods.
        """
        ...
    
    def InterpolateOn(self):
        """
        V.InterpolateOn()
        C++: void InterpolateOn()
        
        Convenient methods for switching between nearest-neighbor and
        linear interpolation. InterpolateOn() is equivalent to
        SetInterpolationModeToLinear() and InterpolateOff() is equivalent
        to SetInterpolationModeToNearestNeighbor() You should not use
        these methods if you use the SetInterpolationMode methods.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Return 1 if this class is the same type of (or a subclass of) the
        named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Return 1 if this class type is the same type of (or a subclass
        of) the named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def MirrorOff(self):
        """
        V.MirrorOff()
        C++: virtual void MirrorOff()
        
        Turn on mirror-pad feature (default: Off). This will override the
        wrap-pad.
        """
        ...
    
    def MirrorOn(self):
        """
        V.MirrorOn()
        C++: virtual void MirrorOn()
        
        Turn on mirror-pad feature (default: Off). This will override the
        wrap-pad.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkImageReslice
        C++: vtkImageReslice *NewInstance()
        """
        ...
    
    def OptimizationOff(self):
        """
        V.OptimizationOff()
        C++: virtual void OptimizationOff()
        
        Turn on and off optimizations (default on, they should only be
        turned off for testing purposes).
        """
        ...
    
    def OptimizationOn(self):
        """
        V.OptimizationOn()
        C++: virtual void OptimizationOn()
        
        Turn on and off optimizations (default on, they should only be
        turned off for testing purposes).
        """
        ...
    
    def ReportReferences(self, vtkGarbageCollector):
        """
        V.ReportReferences(vtkGarbageCollector)
        C++: void ReportReferences(vtkGarbageCollector *) override;
        
        Report object referenced by instances of this class.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkImageReslice
        C++: static vtkImageReslice *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def SetAutoCropOutput(self, p_int):
        """
        V.SetAutoCropOutput(int)
        C++: virtual void SetAutoCropOutput(vtkTypeBool _arg)
        
        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).
        """
        ...
    
    def SetBackgroundColor(self, p_float, p_float_1, p_float_2, p_float_3):
        """
        V.SetBackgroundColor(float, float, float, float)
        C++: virtual void SetBackgroundColor(double _arg1, double _arg2,
            double _arg3, double _arg4)
        V.SetBackgroundColor((float, float, float, float))
        C++: virtual void SetBackgroundColor(const double _arg[4])
        
        Set the background color (for multi-component images).
        """
        ...
    
    def SetBackgroundLevel(self, p_float):
        """
        V.SetBackgroundLevel(float)
        C++: void SetBackgroundLevel(double v)
        
        Set background grey level (for single-component images).
        """
        ...
    
    def SetBorder(self, p_int):
        """
        V.SetBorder(int)
        C++: virtual void SetBorder(vtkTypeBool _arg)
        
        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.
        """
        ...
    
    def SetBorderThickness(self, p_float):
        """
        V.SetBorderThickness(float)
        C++: virtual void SetBorderThickness(double _arg)
        """
        ...
    
    def SetGenerateStencilOutput(self, p_int):
        """
        V.SetGenerateStencilOutput(int)
        C++: virtual void SetGenerateStencilOutput(vtkTypeBool _arg)
        
        Generate an output stencil that defines which pixels were
        interpolated and which pixels were out-of-bounds of the input.
        """
        ...
    
    def SetInformationInput(self, vtkImageData):
        """
        V.SetInformationInput(vtkImageData)
        C++: virtual void SetInformationInput(vtkImageData *)
        
        Set a vtkImageData from which the default Spacing, Origin, and
        WholeExtent of the output will be copied.  The spacing, origin,
        and extent will be permuted according to the ResliceAxes.  Any
        values set via SetOutputSpacing, SetOutputOrigin, and
        SetOutputExtent will override these values.  By default, the
        Spacing, Origin, and WholeExtent of the Input are used.
        """
        ...
    
    def SetInterpolate(self, p_int):
        """
        V.SetInterpolate(int)
        C++: void SetInterpolate(int t)
        
        Convenient methods for switching between nearest-neighbor and
        linear interpolation. InterpolateOn() is equivalent to
        SetInterpolationModeToLinear() and InterpolateOff() is equivalent
        to SetInterpolationModeToNearestNeighbor() You should not use
        these methods if you use the SetInterpolationMode methods.
        """
        ...
    
    def SetInterpolationMode(self, p_int):
        """
        V.SetInterpolationMode(int)
        C++: virtual void SetInterpolationMode(int _arg)
        
        Set interpolation mode (default: nearest neighbor).
        """
        ...
    
    def SetInterpolationModeToCubic(self):
        """
        V.SetInterpolationModeToCubic()
        C++: void SetInterpolationModeToCubic()
        """
        ...
    
    def SetInterpolationModeToLinear(self):
        """
        V.SetInterpolationModeToLinear()
        C++: void SetInterpolationModeToLinear()
        """
        ...
    
    def SetInterpolationModeToNearestNeighbor(self):
        """
        V.SetInterpolationModeToNearestNeighbor()
        C++: void SetInterpolationModeToNearestNeighbor()
        """
        ...
    
    def SetInterpolator(self, vtkAbstractImageInterpolator):
        """
        V.SetInterpolator(vtkAbstractImageInterpolator)
        C++: virtual void SetInterpolator(
            vtkAbstractImageInterpolator *sampler)
        
        Set the interpolator to use.  The default interpolator supports
        the Nearest, Linear, and Cubic interpolation modes.
        """
        ...
    
    def SetMirror(self, p_int):
        """
        V.SetMirror(int)
        C++: virtual void SetMirror(vtkTypeBool _arg)
        
        Turn on mirror-pad feature (default: Off). This will override the
        wrap-pad.
        """
        ...
    
    def SetOptimization(self, p_int):
        """
        V.SetOptimization(int)
        C++: virtual void SetOptimization(vtkTypeBool _arg)
        
        Turn on and off optimizations (default on, they should only be
        turned off for testing purposes).
        """
        ...
    
    def SetOutputDimensionality(self, p_int):
        """
        V.SetOutputDimensionality(int)
        C++: virtual void SetOutputDimensionality(int _arg)
        
        Force the dimensionality of the output to either 1, 2, 3 or 0
        (default: 3).  If the dimensionality is 2D, 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 1D, the output extent is
        confined to the x axis. For 0D, the output extent consists of a
        single voxel at (0,0,0).
        """
        ...
    
    def SetOutputExtent(self, p_int, p_int_1, p_int_2, p_int_3, p_int_4, p_int_5):
        """
        V.SetOutputExtent(int, int, int, int, int, int)
        C++: virtual void SetOutputExtent(int a, int b, int c, int d,
            int e, int f)
        V.SetOutputExtent((int, int, int, int, int, int))
        C++: virtual void SetOutputExtent(const int a[6])
        
        Set the extent for the output data.  The default output extent is
        the input extent permuted through the ResliceAxes.
        """
        ...
    
    def SetOutputExtentToDefault(self):
        """
        V.SetOutputExtentToDefault()
        C++: void SetOutputExtentToDefault()
        
        Set the extent for the output data.  The default output extent is
        the input extent permuted through the ResliceAxes.
        """
        ...
    
    def SetOutputOrigin(self, p_float, p_float_1, p_float_2):
        """
        V.SetOutputOrigin(float, float, float)
        C++: virtual void SetOutputOrigin(double x, double y, double z)
        V.SetOutputOrigin((float, float, float))
        C++: virtual void SetOutputOrigin(const double a[3])
        
        Set the origin for the output data.  The default output origin is
        the input origin permuted through the ResliceAxes.
        """
        ...
    
    def SetOutputOriginToDefault(self):
        """
        V.SetOutputOriginToDefault()
        C++: void SetOutputOriginToDefault()
        
        Set the origin for the output data.  The default output origin is
        the input origin permuted through the ResliceAxes.
        """
        ...
    
    def SetOutputScalarType(self, p_int):
        """
        V.SetOutputScalarType(int)
        C++: virtual void SetOutputScalarType(int _arg)
        
        Set the scalar type of the output to be different from the input.
        The default value is -1, which means that the input scalar type
        will be used to set the output scalar type.  Otherwise, this must
        be set to one of the following types: VTK_CHAR, VTK_SIGNED_CHAR,
        VTK_UNSIGNED_CHAR, VTK_SHORT, VTK_UNSIGNED_SHORT, VTK_INT,
        VTK_UNSIGNED_INT, VTK_FLOAT, or VTK_DOUBLE.  Other types are not
        permitted.  If the output type is an integer type, the output
        will be rounded and clamped to the limits of the type.
        """
        ...
    
    def SetOutputSpacing(self, p_float, p_float_1, p_float_2):
        """
        V.SetOutputSpacing(float, float, float)
        C++: virtual void SetOutputSpacing(double x, double y, double z)
        V.SetOutputSpacing((float, float, float))
        C++: virtual void SetOutputSpacing(const double a[3])
        
        Set the voxel spacing for the output data.  The default output
        spacing is the input spacing permuted through the ResliceAxes.
        """
        ...
    
    def SetOutputSpacingToDefault(self):
        """
        V.SetOutputSpacingToDefault()
        C++: void SetOutputSpacingToDefault()
        
        Set the voxel spacing for the output data.  The default output
        spacing is the input spacing permuted through the ResliceAxes.
        """
        ...
    
    def SetResliceAxes(self, vtkMatrix4x4):
        """
        V.SetResliceAxes(vtkMatrix4x4)
        C++: virtual void SetResliceAxes(vtkMatrix4x4 *)
        
        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
        ResliceAxes are used most often to permute the data, e.g. to
        extract ZY or XZ slices of a volume as 2D XY 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 SetResliceAxes() is to use
        SetResliceAxesDirectionCosines() to set the directions of the
        axes and SetResliceAxesOrigin() to set the origin of the axes.
        """
        ...
    
    def SetResliceAxesDirectionCosines(self, p_float, p_float_1, p_float_2, p_float_3, p_float_4, p_float_5, p_float_6, p_float_7, p_float_8):
        """
        V.SetResliceAxesDirectionCosines(float, float, float, float,
            float, float, float, float, float)
        C++: void SetResliceAxesDirectionCosines(double x0, double x1,
            double x2, double y0, double y1, double y2, double z0,
            double z1, double z2)
        V.SetResliceAxesDirectionCosines((float, float, float), (float,
            float, float), (float, float, float))
        C++: void SetResliceAxesDirectionCosines(const double x[3],
            const double y[3], const double z[3])
        V.SetResliceAxesDirectionCosines((float, float, float, float,
            float, float, float, float, float))
        C++: void SetResliceAxesDirectionCosines(const double xyz[9])
        
        Specify the direction cosines for the ResliceAxes (i.e. the first
        three elements of each of the first three columns of the
        ResliceAxes matrix).  This will modify the current ResliceAxes
        matrix, or create a new matrix if none exists.
        """
        ...
    
    def SetResliceAxesOrigin(self, p_float, p_float_1, p_float_2):
        """
        V.SetResliceAxesOrigin(float, float, float)
        C++: void SetResliceAxesOrigin(double x, double y, double z)
        V.SetResliceAxesOrigin((float, float, float))
        C++: void SetResliceAxesOrigin(const double xyz[3])
        
        Specify the origin for the ResliceAxes (i.e. the first three
        elements of the final column of the ResliceAxes matrix). This
        will modify the current ResliceAxes matrix, or create new matrix
        if none exists.
        """
        ...
    
    def SetResliceTransform(self, vtkAbstractTransform):
        """
        V.SetResliceTransform(vtkAbstractTransform)
        C++: virtual void SetResliceTransform(vtkAbstractTransform *)
        
        Set a transform to be applied to the resampling grid that has
        been defined via the ResliceAxes 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 vtkGridTransform and
        vtkThinPlateSplineTransform can be used here.
        """
        ...
    
    def SetScalarScale(self, p_float):
        """
        V.SetScalarScale(float)
        C++: virtual void SetScalarScale(double _arg)
        
        Set multiplication factor to apply to all the output voxels.
        After a sample value has been interpolated from the input image,
        the equation u = (v + ScalarShift)*ScalarScale will be applied to
        it before it is written to the output image.  The result will
        always be clamped to the limits of the output data type.
        """
        ...
    
    def SetScalarShift(self, p_float):
        """
        V.SetScalarShift(float)
        C++: virtual void SetScalarShift(double _arg)
        
        Set a value to add to all the output voxels. After a sample value
        has been interpolated from the input image, the equation u = (v +
        ScalarShift)*ScalarScale will be applied to it before it is
        written to the output image.  The result will always be clamped
        to the limits of the output data type.
        """
        ...
    
    def SetSlabMode(self, p_int):
        """
        V.SetSlabMode(int)
        C++: virtual void SetSlabMode(int _arg)
        
        Set the slab mode, for generating thick slices. The default is
        Mean. If SetSlabNumberOfSlices(N) is called with N greater than
        one, then each output slice will actually be a composite of N
        slices.  This method specifies the compositing mode to be used.
        """
        ...
    
    def SetSlabModeToMax(self):
        """
        V.SetSlabModeToMax()
        C++: void SetSlabModeToMax()
        
        Set the slab mode, for generating thick slices. The default is
        Mean. If SetSlabNumberOfSlices(N) is called with N greater than
        one, then each output slice will actually be a composite of N
        slices.  This method specifies the compositing mode to be used.
        """
        ...
    
    def SetSlabModeToMean(self):
        """
        V.SetSlabModeToMean()
        C++: void SetSlabModeToMean()
        
        Set the slab mode, for generating thick slices. The default is
        Mean. If SetSlabNumberOfSlices(N) is called with N greater than
        one, then each output slice will actually be a composite of N
        slices.  This method specifies the compositing mode to be used.
        """
        ...
    
    def SetSlabModeToMin(self):
        """
        V.SetSlabModeToMin()
        C++: void SetSlabModeToMin()
        
        Set the slab mode, for generating thick slices. The default is
        Mean. If SetSlabNumberOfSlices(N) is called with N greater than
        one, then each output slice will actually be a composite of N
        slices.  This method specifies the compositing mode to be used.
        """
        ...
    
    def SetSlabModeToSum(self):
        """
        V.SetSlabModeToSum()
        C++: void SetSlabModeToSum()
        
        Set the slab mode, for generating thick slices. The default is
        Mean. If SetSlabNumberOfSlices(N) is called with N greater than
        one, then each output slice will actually be a composite of N
        slices.  This method specifies the compositing mode to be used.
        """
        ...
    
    def SetSlabNumberOfSlices(self, p_int):
        """
        V.SetSlabNumberOfSlices(int)
        C++: virtual void SetSlabNumberOfSlices(int _arg)
        
        Set the number of slices that will be combined to create the
        slab.
        """
        ...
    
    def SetSlabSliceSpacingFraction(self, p_float):
        """
        V.SetSlabSliceSpacingFraction(float)
        C++: virtual void SetSlabSliceSpacingFraction(double _arg)
        
        The slab spacing as a fraction of the output slice spacing. When
        one of the various slab modes is chosen, each output slice is
        produced by generating several "temporary" output slices and then
        combining them according to the slab mode.  By default, the
        spacing between these temporary slices is the Z component of the
        OutputSpacing. This method sets the spacing between these
        temporary slices to be a fraction of the output spacing.
        """
        ...
    
    def SetSlabTrapezoidIntegration(self, p_int):
        """
        V.SetSlabTrapezoidIntegration(int)
        C++: virtual void SetSlabTrapezoidIntegration(vtkTypeBool _arg)
        
        Use trapezoid integration for slab computation.  All this does is
        weigh the first and last slices by half when doing sum and mean.
        It is off by default.
        """
        ...
    
    def SetStencilData(self, vtkImageStencilData):
        """
        V.SetStencilData(vtkImageStencilData)
        C++: void SetStencilData(vtkImageStencilData *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.
        """
        ...
    
    def SetStencilOutput(self, vtkImageStencilData):
        """
        V.SetStencilOutput(vtkImageStencilData)
        C++: void SetStencilOutput(vtkImageStencilData *stencil)
        
        Get the output stencil.
        """
        ...
    
    def SetTransformInputSampling(self, p_int):
        """
        V.SetTransformInputSampling(int)
        C++: virtual void SetTransformInputSampling(vtkTypeBool _arg)
        
        Specify whether to transform the spacing, origin and extent of
        the Input (or the InformationInput) according to the direction
        cosines and origin of the ResliceAxes before applying them as the
        default output spacing, origin and extent (default: On).
        """
        ...
    
    def SetWrap(self, p_int):
        """
        V.SetWrap(int)
        C++: virtual void SetWrap(vtkTypeBool _arg)
        
        Turn on wrap-pad feature (default: Off).
        """
        ...
    
    def SlabTrapezoidIntegrationOff(self):
        """
        V.SlabTrapezoidIntegrationOff()
        C++: virtual void SlabTrapezoidIntegrationOff()
        
        Use trapezoid integration for slab computation.  All this does is
        weigh the first and last slices by half when doing sum and mean.
        It is off by default.
        """
        ...
    
    def SlabTrapezoidIntegrationOn(self):
        """
        V.SlabTrapezoidIntegrationOn()
        C++: virtual void SlabTrapezoidIntegrationOn()
        
        Use trapezoid integration for slab computation.  All this does is
        weigh the first and last slices by half when doing sum and mean.
        It is off by default.
        """
        ...
    
    def TransformInputSamplingOff(self):
        """
        V.TransformInputSamplingOff()
        C++: virtual void TransformInputSamplingOff()
        
        Specify whether to transform the spacing, origin and extent of
        the Input (or the InformationInput) according to the direction
        cosines and origin of the ResliceAxes before applying them as the
        default output spacing, origin and extent (default: On).
        """
        ...
    
    def TransformInputSamplingOn(self):
        """
        V.TransformInputSamplingOn()
        C++: virtual void TransformInputSamplingOn()
        
        Specify whether to transform the spacing, origin and extent of
        the Input (or the InformationInput) according to the direction
        cosines and origin of the ResliceAxes before applying them as the
        default output spacing, origin and extent (default: On).
        """
        ...
    
    def WrapOff(self):
        """
        V.WrapOff()
        C++: virtual void WrapOff()
        
        Turn on wrap-pad feature (default: Off).
        """
        ...
    
    def WrapOn(self):
        """
        V.WrapOn()
        C++: virtual void WrapOn()
        
        Turn on wrap-pad feature (default: Off).
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


