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

import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore
import vtkmodules.vtkRenderingVolume as __vtkmodules_vtkRenderingVolume

class vtkMultiBlockVolumeMapper(__vtkmodules_vtkRenderingVolume.vtkVolumeMapper):
    """
    vtkMultiBlockVolumeMapper - Mapper to render volumes defined as
    vtkMultiBlockDataSet.
    
    Superclass: vtkVolumeMapper
    
    vtkMultiBlockVolumeMapper renders vtkMultiBlockDataSet instances
    containing vtkImageData blocks (all of the blocks are expected to be
    vtkImageData). Bounds containing the full set of blocks are computed
    so that vtkRenderer can adjust the clipping planes appropriately.
    
    This mapper creates an instance of vtkSmartVolumeMapper per block to
    which it defers the actual rendering.  At render time, blocks
    (mappers) are sorted back-to-front and each block is rendered
    independently.  It attempts to load all of the blocks at the same
    time but tries to catch allocation errors in which case it falls back
    to using a single mapper instance and reloading data for each block.
    
    Jittering is used to alleviate seam artifacts at the block edges due
    to the discontinuous resolution between blocks.  Jittering is enabled
    by default. Jittering is only supported in GPURenderMode.
    """
    def GetBounds(self):
        """
        V.GetBounds() -> (float, float, float, float, float, float)
        C++: double *GetBounds() override;
        V.GetBounds([float, float, float, float, float, float])
        C++: void GetBounds(double bounds[6]) override;
        
        API Superclass
        \sa vtkAbstractVolumeMapper
        """
        ...
    
    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 GetVectorComponent(self):
        """
        V.GetVectorComponent() -> int
        C++: virtual int GetVectorComponent()
        
        VectorMode interface exposed from vtkSmartVolumeMapper.
        """
        ...
    
    def GetVectorMode(self):
        """
        V.GetVectorMode() -> int
        C++: virtual int GetVectorMode()
        
        VectorMode interface exposed from vtkSmartVolumeMapper.
        """
        ...
    
    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 NewInstance(self):
        """
        V.NewInstance() -> vtkMultiBlockVolumeMapper
        C++: vtkMultiBlockVolumeMapper *NewInstance()
        """
        ...
    
    def ReleaseGraphicsResources(self, vtkWindow):
        """
        V.ReleaseGraphicsResources(vtkWindow)
        C++: void ReleaseGraphicsResources(vtkWindow *window) override;
        
        \warning Internal method - not intended for general use, do
        NOT use this method outside of the rendering process.
        """
        ...
    
    def Render(self, vtkRenderer, vtkVolume):
        """
        V.Render(vtkRenderer, vtkVolume)
        C++: void Render(vtkRenderer *ren, vtkVolume *vol) override;
        
        Render the current dataset.
        
        \warning Internal method - not intended for general use, do
        NOT use this method outside of the rendering process.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkMultiBlockVolumeMapper
        C++: static vtkMultiBlockVolumeMapper *SafeDownCast(
            vtkObjectBase *o)
        """
        ...
    
    def SelectScalarArray(self, p_int):
        """
        V.SelectScalarArray(int)
        C++: void SelectScalarArray(int arrayNum) override;
        V.SelectScalarArray(string)
        C++: void SelectScalarArray(char const *arrayName) override;
        
        API Superclass
        \sa vtkAbstractVolumeMapper
        """
        ...
    
    def SetArrayAccessMode(self, p_int):
        """
        V.SetArrayAccessMode(int)
        C++: void SetArrayAccessMode(int accessMode) override;
        
        API Superclass
        \sa vtkAbstractVolumeMapper
        """
        ...
    
    def SetBlendMode(self, p_int):
        """
        V.SetBlendMode(int)
        C++: void SetBlendMode(int mode) override;
        
        Blending mode API from vtkVolumeMapper
        \sa vtkVolumeMapper::SetBlendMode
        """
        ...
    
    def SetCropping(self, p_int):
        """
        V.SetCropping(int)
        C++: void SetCropping(vtkTypeBool mode) override;
        
        Cropping API from vtkVolumeMapper
        \sa vtkVolumeMapper::SetCropping
        """
        ...
    
    def SetCroppingRegionFlags(self, p_int):
        """
        V.SetCroppingRegionFlags(int)
        C++: void SetCroppingRegionFlags(int mode) override;
        
        \sa vtkVolumeMapper::SetCroppingRegionFlags
        """
        ...
    
    def SetCroppingRegionPlanes(self, p_float, p_float_1, p_float_2, p_float_3, p_float_4, p_float_5):
        """
        V.SetCroppingRegionPlanes(float, float, float, float, float,
            float)
        C++: void SetCroppingRegionPlanes(double arg1, double arg2,
            double arg3, double arg4, double arg5, double arg6) override;
        V.SetCroppingRegionPlanes((float, float, float, float, float,
            float))
        C++: void SetCroppingRegionPlanes(const double *planes) override;
        
        \sa vtkVolumeMapper::SetCroppingRegionPlanes
        """
        ...
    
    def SetRequestedRenderMode(self, p_int):
        """
        V.SetRequestedRenderMode(int)
        C++: void SetRequestedRenderMode(int)
        
        Forwarded to internal vtkSmartVolumeMappers used.
        @sa vtkSmartVolumeMapper::SetRequestedRenderMode.
        """
        ...
    
    def SetScalarMode(self, p_int):
        """
        V.SetScalarMode(int)
        C++: void SetScalarMode(int ScalarMode) override;
        
        API Superclass
        \sa vtkAbstractVolumeMapper
        """
        ...
    
    def SetVectorComponent(self, p_int):
        """
        V.SetVectorComponent(int)
        C++: void SetVectorComponent(int component)
        
        VectorMode interface exposed from vtkSmartVolumeMapper.
        """
        ...
    
    def SetVectorMode(self, p_int):
        """
        V.SetVectorMode(int)
        C++: void SetVectorMode(int mode)
        
        VectorMode interface exposed from vtkSmartVolumeMapper.
        """
        ...
    
    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__ = ...


class vtkOpenGLGPUVolumeRayCastMapper(__vtkmodules_vtkRenderingVolume.vtkGPUVolumeRayCastMapper):
    """
    vtkOpenGLGPUVolumeRayCastMapper - OpenGL implementation of volume
    rendering through ray-casting.
    
    Superclass: vtkGPUVolumeRayCastMapper
    
    @section multi Multiple Inputs
    
    * When multiple inputs are rendered simultaneously, it is possible to
    * composite overlapping areas correctly. Inputs are connected
      directly to
    * the mapper and their parameters (transfer functions,
      transformations, etc.)
    * are specified through standard vtkVolume instances. These vtkVolume
    * instances are to be registered in a special vtkProp3D,
      vtkMultiVolume.
    *
    * Structures related to a particular active input are stored in a
      helper
    * class (vtkVolumeInputHelper) and helper structures are kept in a
    * port-referenced map (VolumeInputMap). The order of the inputs in
      the
    * map is important as it defines the order in which parameters are
    * bound to uniform variables (transformation matrices, bias, scale
      and every
    * other required rendering parameter).
    *
    * A separate code path is used when rendering multiple-inputs in
      order to
    * facilitate the co-existance of these two modes (single/multiple),
      due to
    * current feature incompatibilities with multiple inputs (e.g.
      texture-streaming,
    * cropping, etc.).
    *
    *
    
    ote A limited set of the mapper features are currently supported for
    * multiple inputs:
    *
    * - Blending
    *   - Composite (front-to-back)
    *
    * - Transfer functions (defined separately for per input)
    *   - 1D color
    *   - 1D scalar opacity
    *   - 1D gradient magnitude opacity
    *   - 2D scalar-gradient magnitude
    *
    * - Point and cell data
    *   - With the limitation that all of the inputs are assumed to share
    the same
    *     name/id.
    *
    * @sa vtkGPUVolumeRayCastMapper vtkVolumeInputHelper vtkVolumeTexture
    * vtkMultiVolume
    *
    """
    def GetColorImage(self, vtkImageData):
        """
        V.GetColorImage(vtkImageData)
        C++: void GetColorImage(vtkImageData *im) override;
        
        Low level API to export the color texture as vtkImageData in
        RenderToImage mode.
        """
        ...
    
    def GetColorTexture(self):
        """
        V.GetColorTexture() -> vtkTextureObject
        C++: vtkTextureObject *GetColorTexture()
        
        Low level API to enable access to color texture in
        RenderToTexture mode. It will return either nullptr if
        RenderToImage was never turned on or texture captured the last
        time RenderToImage was on.
        """
        ...
    
    def GetCurrentPass(self):
        """
        V.GetCurrentPass() -> int
        C++: virtual int GetCurrentPass()
        
        Mapper can have multiple passes and internally it will set the
        state. The state can not be set externally explicitly but can be
        set indirectly depending on the options set by the user.
        """
        ...
    
    def GetDepthImage(self, vtkImageData):
        """
        V.GetDepthImage(vtkImageData)
        C++: void GetDepthImage(vtkImageData *im) override;
        
        Low level API to export the depth texture as vtkImageData in
        RenderToImage mode.
        """
        ...
    
    def GetDepthTexture(self):
        """
        V.GetDepthTexture() -> vtkTextureObject
        C++: vtkTextureObject *GetDepthTexture()
        
        Low level API to enable access to depth texture in
        RenderToTexture mode. It will return either nullptr if
        RenderToImage was never turned on or texture captured the last
        time RenderToImage was on.
        """
        ...
    
    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 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 NewInstance(self):
        """
        V.NewInstance() -> vtkOpenGLGPUVolumeRayCastMapper
        C++: vtkOpenGLGPUVolumeRayCastMapper *NewInstance()
        """
        ...
    
    def PreLoadData(self, vtkRenderer, vtkVolume):
        """
        V.PreLoadData(vtkRenderer, vtkVolume) -> bool
        C++: bool PreLoadData(vtkRenderer *ren, vtkVolume *vol)
        
        Load the volume texture into GPU memory.  Actual loading occurs
        in vtkVolumeTexture::LoadVolume.  The mapper by default loads
        data lazily (at render time), so it is most commonly not
        necessary to call this function.  This method is only exposed in
        order to support on-site loading which is useful in cases where
        the user needs to know a-priori whether loading will succeed or
        not.
        """
        ...
    
    def ReleaseGraphicsResources(self, vtkWindow):
        """
        V.ReleaseGraphicsResources(vtkWindow)
        C++: void ReleaseGraphicsResources(vtkWindow *window) override;
        
        Delete OpenGL objects.
        \post done: this->OpenGLObjectsCreated==0
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkOpenGLGPUVolumeRayCastMapper
        C++: static vtkOpenGLGPUVolumeRayCastMapper *SafeDownCast(
            vtkObjectBase *o)
        """
        ...
    
    def SetPartitions(self, p_int, p_int_1, p_int_2):
        """
        V.SetPartitions(int, int, int)
        C++: void SetPartitions(unsigned short x, unsigned short y,
            unsigned short z)
        
        Set a fixed number of partitions in which to split the volume
        during rendring. This will force by-block rendering without
        trying to compute an optimum number of partitions.
        """
        ...
    
    def SetSharedDepthTexture(self, vtkTextureObject):
        """
        V.SetSharedDepthTexture(vtkTextureObject)
        C++: void SetSharedDepthTexture(vtkTextureObject *nt)
        """
        ...
    
    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__ = ...
    DepthPass = ...
    Passes = ...
    RenderPass = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkOpenGLProjectedTetrahedraMapper(__vtkmodules_vtkRenderingVolume.vtkProjectedTetrahedraMapper):
    """
    vtkOpenGLProjectedTetrahedraMapper - OpenGL implementation of PT
    
    Superclass: vtkProjectedTetrahedraMapper
    
    @bug This mapper relies highly on the implementation of the OpenGL
    pipeline. A typical hardware driver has lots of options and some
    settings can cause this mapper to produce artifacts.
    """
    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 GetUseFloatingPointFrameBuffer(self):
        """
        V.GetUseFloatingPointFrameBuffer() -> bool
        C++: virtual bool GetUseFloatingPointFrameBuffer()
        
        Set/get whether to use floating-point rendering buffers rather
        than the default.
        """
        ...
    
    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 IsSupported(self, vtkRenderWindow):
        """
        V.IsSupported(vtkRenderWindow) -> bool
        C++: bool IsSupported(vtkRenderWindow *context) override;
        
        Return true if the rendering context provides the nececessary
        functionality to use this class.
        """
        ...
    
    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 NewInstance(self):
        """
        V.NewInstance() -> vtkOpenGLProjectedTetrahedraMapper
        C++: vtkOpenGLProjectedTetrahedraMapper *NewInstance()
        """
        ...
    
    def ReleaseGraphicsResources(self, vtkWindow):
        """
        V.ReleaseGraphicsResources(vtkWindow)
        C++: void ReleaseGraphicsResources(vtkWindow *window) override;
        
        WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE Release
        any graphics resources that are being consumed by this mapper.
        The parameter window could be used to determine which graphic
        resources to release.
        """
        ...
    
    def Render(self, vtkRenderer, vtkVolume):
        """
        V.Render(vtkRenderer, vtkVolume)
        C++: void Render(vtkRenderer *renderer, vtkVolume *volume)
            override;
        
        WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE DO NOT
        USE THIS METHOD OUTSIDE OF THE RENDERING PROCESS Render the
        volume
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase)
            -> vtkOpenGLProjectedTetrahedraMapper
        C++: static vtkOpenGLProjectedTetrahedraMapper *SafeDownCast(
            vtkObjectBase *o)
        """
        ...
    
    def SetUseFloatingPointFrameBuffer(self, bool):
        """
        V.SetUseFloatingPointFrameBuffer(bool)
        C++: virtual void SetUseFloatingPointFrameBuffer(bool _arg)
        
        Set/get whether to use floating-point rendering buffers rather
        than the default.
        """
        ...
    
    def UseFloatingPointFrameBufferOff(self):
        """
        V.UseFloatingPointFrameBufferOff()
        C++: virtual void UseFloatingPointFrameBufferOff()
        
        Set/get whether to use floating-point rendering buffers rather
        than the default.
        """
        ...
    
    def UseFloatingPointFrameBufferOn(self):
        """
        V.UseFloatingPointFrameBufferOn()
        C++: virtual void UseFloatingPointFrameBufferOn()
        
        Set/get whether to use floating-point rendering buffers rather
        than the default.
        """
        ...
    
    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__ = ...


class vtkOpenGLRayCastImageDisplayHelper(__vtkmodules_vtkRenderingVolume.vtkRayCastImageDisplayHelper):
    """
    vtkOpenGLRayCastImageDisplayHelper - OpenGL subclass that draws the
    image to the screen
    
    Superclass: vtkRayCastImageDisplayHelper
    
    This is the concrete implementation of a ray cast image display
    helper - a helper class responsible for drawing the image to the
    screen.
    
    @sa
    vtkRayCastImageDisplayHelper
    """
    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 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 NewInstance(self):
        """
        V.NewInstance() -> vtkOpenGLRayCastImageDisplayHelper
        C++: vtkOpenGLRayCastImageDisplayHelper *NewInstance()
        """
        ...
    
    def ReleaseGraphicsResources(self, vtkWindow):
        """
        V.ReleaseGraphicsResources(vtkWindow)
        C++: void ReleaseGraphicsResources(vtkWindow *win) override;
        
        Derived class should implement this if needed
        """
        ...
    
    def RenderTexture(self, vtkVolume, vtkRenderer, p_int=..., p_int=..., *args, **kwargs):
        """
        V.RenderTexture(vtkVolume, vtkRenderer, [int, int], [int, int],
            [int, int], [int, int], float, [int, ...])
        C++: void RenderTexture(vtkVolume *vol, vtkRenderer *ren,
            int imageMemorySize[2], int imageViewportSize[2],
            int imageInUseSize[2], int imageOrigin[2],
            float requestedDepth, unsigned char *image) override;
        V.RenderTexture(vtkVolume, vtkRenderer, [int, int], [int, int],
            [int, int], [int, int], float, [int, ...])
        C++: void RenderTexture(vtkVolume *vol, vtkRenderer *ren,
            int imageMemorySize[2], int imageViewportSize[2],
            int imageInUseSize[2], int imageOrigin[2],
            float requestedDepth, unsigned short *image) override;
        V.RenderTexture(vtkVolume, vtkRenderer, vtkFixedPointRayCastImage,
             float)
        C++: void RenderTexture(vtkVolume *vol, vtkRenderer *ren,
            vtkFixedPointRayCastImage *image, float requestedDepth)
            override;
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase)
            -> vtkOpenGLRayCastImageDisplayHelper
        C++: static vtkOpenGLRayCastImageDisplayHelper *SafeDownCast(
            vtkObjectBase *o)
        """
        ...
    
    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__ = ...


class vtkSmartVolumeMapper(__vtkmodules_vtkRenderingVolume.vtkVolumeMapper):
    """
    vtkSmartVolumeMapper - Adaptive volume mapper
    
    Superclass: vtkVolumeMapper
    
    vtkSmartVolumeMapper is a volume mapper that will delegate to a
    specific volume mapper based on rendering parameters and available
    hardware. Use the SetRequestedRenderMode() method to control the
    behavior of the selection. The following options are available:
    
    @par vtkSmartVolumeMapper::DefaultRenderMode:
             Allow the vtkSmartVolumeMapper to select the best mapper
    based on
             rendering parameters and hardware support. If GPU ray
    casting is
             supported, this mapper will be used for all rendering. If
    not,
             then the vtkFixedPointRayCastMapper will be used
    exclusively.
             This is the default requested render mode, and is generally
    the
             best option. When you use this option, your volume will
    always
             be rendered, but the method used to render it may vary based
             on parameters and platform.
    
    @par vtkSmartVolumeMapper::RayCastRenderMode:
             Use the vtkFixedPointVolumeRayCastMapper for both
    interactive and
             still rendering. When you use this option your volume will
    always
             be rendered with the vtkFixedPointVolumeRayCastMapper.
    
    @par vtkSmartVolumeMapper::GPURenderMode:
             Use the vtkGPUVolumeRayCastMapper, if supported, for both
             interactive and still rendering. If the GPU ray caster is
    not
             supported (due to hardware limitations or rendering
    parameters)
             then no image will be rendered. Use this option only if you
    have
             already checked for supported based on the current hardware,
             number of scalar components, and rendering parameters in the
             vtkVolumeProperty.
    
    @par vtkSmartVolumeMapper::GPURenderMode:
     You can adjust the contrast and brightness in the rendered image
    using the
     FinalColorWindow and FinalColorLevel ivars. By default the
     FinalColorWindow is set to 1.0, and the FinalColorLevel is set to
    0.5,
     which applies no correction to the computed image. To apply the
    window /
     level operation to the computer image color, first a Scale and Bias
     value are computed:
    
    
     scale = 1.0 / this->FinalColorWindow
     bias  = 0.5 - this->FinalColorLevel / this->FinalColorWindow
     
     To compute a new color (R', G', B', A') from an existing color
    (R,G,B,A)
     for a pixel, the following equation is used:
    
    
     R' = R*scale + bias*A
     G' = G*scale + bias*A
     B' = B*scale + bias*A
     A' = A
      Note that bias is multiplied by the alpha component before adding
    because the red, green, and blue component of the color are already
    pre-multiplied by alpha. Also note that the window / level operation
    leaves the alpha component unchanged - it only adjusts the RGB
    values.
    """
    def AutoAdjustSampleDistancesOff(self):
        """
        V.AutoAdjustSampleDistancesOff()
        C++: virtual void AutoAdjustSampleDistancesOff()
        
        If AutoAdjustSampleDistances is on, the ImageSampleDistance will
        be varied to achieve the allocated render time of this prop
        (controlled by the desired update rate and any culling in use).
        Note that, this flag is ignored when
        InteractiveAdjustSampleDistances is enabled. To explicitly set
        and use this flag, one must disable
        InteractiveAdjustSampleDistances.
        """
        ...
    
    def AutoAdjustSampleDistancesOn(self):
        """
        V.AutoAdjustSampleDistancesOn()
        C++: virtual void AutoAdjustSampleDistancesOn()
        
        If AutoAdjustSampleDistances is on, the ImageSampleDistance will
        be varied to achieve the allocated render time of this prop
        (controlled by the desired update rate and any culling in use).
        Note that, this flag is ignored when
        InteractiveAdjustSampleDistances is enabled. To explicitly set
        and use this flag, one must disable
        InteractiveAdjustSampleDistances.
        """
        ...
    
    def CreateCanonicalView(self, vtkRenderer, vtkVolume, vtkVolume_1, vtkImageData, p_int, p_float=..., p_float=..., p_float=..., *args, **kwargs):
        """
        V.CreateCanonicalView(vtkRenderer, vtkVolume, vtkVolume,
            vtkImageData, int, [float, float, float], [float, float,
            float])
        C++: void CreateCanonicalView(vtkRenderer *ren, vtkVolume *volume,
             vtkVolume *volume2, vtkImageData *image, int blend_mode,
            double viewDirection[3], double viewUp[3])
        
        This method can be used to render a representative view of the
        input data into the supplied image given the supplied blending
        mode, view direction, and view up vector.
        """
        ...
    
    def GetAutoAdjustSampleDistances(self):
        """
        V.GetAutoAdjustSampleDistances() -> int
        C++: virtual vtkTypeBool GetAutoAdjustSampleDistances()
        
        If AutoAdjustSampleDistances is on, the ImageSampleDistance will
        be varied to achieve the allocated render time of this prop
        (controlled by the desired update rate and any culling in use).
        Note that, this flag is ignored when
        InteractiveAdjustSampleDistances is enabled. To explicitly set
        and use this flag, one must disable
        InteractiveAdjustSampleDistances.
        """
        ...
    
    def GetAutoAdjustSampleDistancesMaxValue(self):
        """
        V.GetAutoAdjustSampleDistancesMaxValue() -> int
        C++: virtual vtkTypeBool GetAutoAdjustSampleDistancesMaxValue()
        
        If AutoAdjustSampleDistances is on, the ImageSampleDistance will
        be varied to achieve the allocated render time of this prop
        (controlled by the desired update rate and any culling in use).
        Note that, this flag is ignored when
        InteractiveAdjustSampleDistances is enabled. To explicitly set
        and use this flag, one must disable
        InteractiveAdjustSampleDistances.
        """
        ...
    
    def GetAutoAdjustSampleDistancesMinValue(self):
        """
        V.GetAutoAdjustSampleDistancesMinValue() -> int
        C++: virtual vtkTypeBool GetAutoAdjustSampleDistancesMinValue()
        
        If AutoAdjustSampleDistances is on, the ImageSampleDistance will
        be varied to achieve the allocated render time of this prop
        (controlled by the desired update rate and any culling in use).
        Note that, this flag is ignored when
        InteractiveAdjustSampleDistances is enabled. To explicitly set
        and use this flag, one must disable
        InteractiveAdjustSampleDistances.
        """
        ...
    
    def GetFinalColorLevel(self):
        """
        V.GetFinalColorLevel() -> float
        C++: virtual float GetFinalColorLevel()
        
        Get the final color level.
        """
        ...
    
    def GetFinalColorWindow(self):
        """
        V.GetFinalColorWindow() -> float
        C++: virtual float GetFinalColorWindow()
        
        Get the final color window. Initial value is 1.0.
        """
        ...
    
    def GetInteractiveAdjustSampleDistances(self):
        """
        V.GetInteractiveAdjustSampleDistances() -> int
        C++: virtual vtkTypeBool GetInteractiveAdjustSampleDistances()
        
        If the InteractiveAdjustSampleDistances flag is enabled,
        vtkSmartVolumeMapper interactively sets and resets the
        AutoAdjustSampleDistances flag on the internal volume mapper.
        This flag along with InteractiveUpdateRate is useful to adjust
        volume mapper sample distance based on whether the render is
        interactive or still. By default,
        InteractiveAdjustSampleDistances is enabled.
        """
        ...
    
    def GetInteractiveAdjustSampleDistancesMaxValue(self):
        """
        V.GetInteractiveAdjustSampleDistancesMaxValue() -> int
        C++: virtual vtkTypeBool GetInteractiveAdjustSampleDistancesMaxValue(
            )
        
        If the InteractiveAdjustSampleDistances flag is enabled,
        vtkSmartVolumeMapper interactively sets and resets the
        AutoAdjustSampleDistances flag on the internal volume mapper.
        This flag along with InteractiveUpdateRate is useful to adjust
        volume mapper sample distance based on whether the render is
        interactive or still. By default,
        InteractiveAdjustSampleDistances is enabled.
        """
        ...
    
    def GetInteractiveAdjustSampleDistancesMinValue(self):
        """
        V.GetInteractiveAdjustSampleDistancesMinValue() -> int
        C++: virtual vtkTypeBool GetInteractiveAdjustSampleDistancesMinValue(
            )
        
        If the InteractiveAdjustSampleDistances flag is enabled,
        vtkSmartVolumeMapper interactively sets and resets the
        AutoAdjustSampleDistances flag on the internal volume mapper.
        This flag along with InteractiveUpdateRate is useful to adjust
        volume mapper sample distance based on whether the render is
        interactive or still. By default,
        InteractiveAdjustSampleDistances is enabled.
        """
        ...
    
    def GetInteractiveUpdateRate(self):
        """
        V.GetInteractiveUpdateRate() -> float
        C++: virtual double GetInteractiveUpdateRate()
        
        Get the update rate at or above which this is considered an
        interactive render. Initial value is 1.0.
        """
        ...
    
    def GetInteractiveUpdateRateMaxValue(self):
        """
        V.GetInteractiveUpdateRateMaxValue() -> float
        C++: virtual double GetInteractiveUpdateRateMaxValue()
        
        If the DesiredUpdateRate of the vtkRenderWindow that caused the
        Render falls at or above this rate, the render is considered
        interactive and the mapper may be adjusted (depending on the
        render mode). Initial value is 1.0.
        """
        ...
    
    def GetInteractiveUpdateRateMinValue(self):
        """
        V.GetInteractiveUpdateRateMinValue() -> float
        C++: virtual double GetInteractiveUpdateRateMinValue()
        
        If the DesiredUpdateRate of the vtkRenderWindow that caused the
        Render falls at or above this rate, the render is considered
        interactive and the mapper may be adjusted (depending on the
        render mode). Initial value is 1.0.
        """
        ...
    
    def GetInterpolationMode(self):
        """
        V.GetInterpolationMode() -> int
        C++: virtual int GetInterpolationMode()
        
        Set interpolation mode for downsampling (lowres GPU) (initial
        value: cubic).
        """
        ...
    
    def GetInterpolationModeMaxValue(self):
        """
        V.GetInterpolationModeMaxValue() -> int
        C++: virtual int GetInterpolationModeMaxValue()
        
        Set interpolation mode for downsampling (lowres GPU) (initial
        value: cubic).
        """
        ...
    
    def GetInterpolationModeMinValue(self):
        """
        V.GetInterpolationModeMinValue() -> int
        C++: virtual int GetInterpolationModeMinValue()
        
        Set interpolation mode for downsampling (lowres GPU) (initial
        value: cubic).
        """
        ...
    
    def GetLastUsedRenderMode(self):
        """
        V.GetLastUsedRenderMode() -> int
        C++: int GetLastUsedRenderMode()
        
        This will return the render mode used during the previous call to
        Render().
        """
        ...
    
    def GetMaxMemoryFraction(self):
        """
        V.GetMaxMemoryFraction() -> float
        C++: virtual float GetMaxMemoryFraction()
        
        Value passed to the GPU mapper. Ignored by other mappers. Maximum
        fraction of the MaxMemoryInBytes that should be used to hold the
        texture. Valid values are 0.1 to 1.0.
        """
        ...
    
    def GetMaxMemoryFractionMaxValue(self):
        """
        V.GetMaxMemoryFractionMaxValue() -> float
        C++: virtual float GetMaxMemoryFractionMaxValue()
        
        Value passed to the GPU mapper. Ignored by other mappers. Maximum
        fraction of the MaxMemoryInBytes that should be used to hold the
        texture. Valid values are 0.1 to 1.0.
        """
        ...
    
    def GetMaxMemoryFractionMinValue(self):
        """
        V.GetMaxMemoryFractionMinValue() -> float
        C++: virtual float GetMaxMemoryFractionMinValue()
        
        Value passed to the GPU mapper. Ignored by other mappers. Maximum
        fraction of the MaxMemoryInBytes that should be used to hold the
        texture. Valid values are 0.1 to 1.0.
        """
        ...
    
    def GetMaxMemoryInBytes(self):
        """
        V.GetMaxMemoryInBytes() -> int
        C++: virtual vtkIdType GetMaxMemoryInBytes()
        
        Value passed to the GPU mapper. Ignored by other mappers. Maximum
        size of the 3D texture in GPU memory. Will default to the size
        computed from the graphics card. Can be adjusted by the user.
        Useful if the automatic detection is defective or missing.
        """
        ...
    
    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 GetRequestedRenderMode(self):
        """
        V.GetRequestedRenderMode() -> int
        C++: virtual int GetRequestedRenderMode()
        
        Get the requested render mode.
        """
        ...
    
    def GetSampleDistance(self):
        """
        V.GetSampleDistance() -> float
        C++: virtual float GetSampleDistance()
        
        Set/Get the distance between samples used for rendering when
        AutoAdjustSampleDistances is off, or when this mapper has more
        than 1 second allocated to it for rendering. If SampleDistance is
        negative, it will be computed based on the dataset spacing.
        Initial value is -1.0.
        """
        ...
    
    def GetVectorComponent(self):
        """
        V.GetVectorComponent() -> int
        C++: virtual int GetVectorComponent()
        
        VectorMode is a special rendering mode for 3-component vectors
        which makes use of GPURayCastMapper's independent-component
        capabilities. In this mode, a single component in the vector can
        be selected for rendering. In addition, the mapper can compute a
        scalar field representing the magnitude of this vector using a
        vtkImageMagnitude object (MAGNITUDE mode).
        """
        ...
    
    def GetVectorComponentMaxValue(self):
        """
        V.GetVectorComponentMaxValue() -> int
        C++: virtual int GetVectorComponentMaxValue()
        
        VectorMode is a special rendering mode for 3-component vectors
        which makes use of GPURayCastMapper's independent-component
        capabilities. In this mode, a single component in the vector can
        be selected for rendering. In addition, the mapper can compute a
        scalar field representing the magnitude of this vector using a
        vtkImageMagnitude object (MAGNITUDE mode).
        """
        ...
    
    def GetVectorComponentMinValue(self):
        """
        V.GetVectorComponentMinValue() -> int
        C++: virtual int GetVectorComponentMinValue()
        
        VectorMode is a special rendering mode for 3-component vectors
        which makes use of GPURayCastMapper's independent-component
        capabilities. In this mode, a single component in the vector can
        be selected for rendering. In addition, the mapper can compute a
        scalar field representing the magnitude of this vector using a
        vtkImageMagnitude object (MAGNITUDE mode).
        """
        ...
    
    def GetVectorMode(self):
        """
        V.GetVectorMode() -> int
        C++: virtual int GetVectorMode()
        
        VectorMode is a special rendering mode for 3-component vectors
        which makes use of GPURayCastMapper's independent-component
        capabilities. In this mode, a single component in the vector can
        be selected for rendering. In addition, the mapper can compute a
        scalar field representing the magnitude of this vector using a
        vtkImageMagnitude object (MAGNITUDE mode).
        """
        ...
    
    def InteractiveAdjustSampleDistancesOff(self):
        """
        V.InteractiveAdjustSampleDistancesOff()
        C++: virtual void InteractiveAdjustSampleDistancesOff()
        
        If the InteractiveAdjustSampleDistances flag is enabled,
        vtkSmartVolumeMapper interactively sets and resets the
        AutoAdjustSampleDistances flag on the internal volume mapper.
        This flag along with InteractiveUpdateRate is useful to adjust
        volume mapper sample distance based on whether the render is
        interactive or still. By default,
        InteractiveAdjustSampleDistances is enabled.
        """
        ...
    
    def InteractiveAdjustSampleDistancesOn(self):
        """
        V.InteractiveAdjustSampleDistancesOn()
        C++: virtual void InteractiveAdjustSampleDistancesOn()
        
        If the InteractiveAdjustSampleDistances flag is enabled,
        vtkSmartVolumeMapper interactively sets and resets the
        AutoAdjustSampleDistances flag on the internal volume mapper.
        This flag along with InteractiveUpdateRate is useful to adjust
        volume mapper sample distance based on whether the render is
        interactive or still. By default,
        InteractiveAdjustSampleDistances is enabled.
        """
        ...
    
    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 NewInstance(self):
        """
        V.NewInstance() -> vtkSmartVolumeMapper
        C++: vtkSmartVolumeMapper *NewInstance()
        """
        ...
    
    def ReleaseGraphicsResources(self, vtkWindow):
        """
        V.ReleaseGraphicsResources(vtkWindow)
        C++: void ReleaseGraphicsResources(vtkWindow *) override;
        
        WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE Release
        any graphics resources that are being consumed by this mapper.
        The parameter window could be used to determine which graphic
        resources to release.
        """
        ...
    
    def Render(self, vtkRenderer, vtkVolume):
        """
        V.Render(vtkRenderer, vtkVolume)
        C++: void Render(vtkRenderer *, vtkVolume *) override;
        
        WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE
        Initialize rendering for this volume.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkSmartVolumeMapper
        C++: static vtkSmartVolumeMapper *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def SetAutoAdjustSampleDistances(self, p_int):
        """
        V.SetAutoAdjustSampleDistances(int)
        C++: virtual void SetAutoAdjustSampleDistances(vtkTypeBool _arg)
        
        If AutoAdjustSampleDistances is on, the ImageSampleDistance will
        be varied to achieve the allocated render time of this prop
        (controlled by the desired update rate and any culling in use).
        Note that, this flag is ignored when
        InteractiveAdjustSampleDistances is enabled. To explicitly set
        and use this flag, one must disable
        InteractiveAdjustSampleDistances.
        """
        ...
    
    def SetFinalColorLevel(self, p_float):
        """
        V.SetFinalColorLevel(float)
        C++: virtual void SetFinalColorLevel(float _arg)
        
        Set the final color level. The level controls the brightness of
        the image. The final color window will be centered at the final
        color level, and together represent a linear remapping of color
        values. The default value for the level is 0.5.
        """
        ...
    
    def SetFinalColorWindow(self, p_float):
        """
        V.SetFinalColorWindow(float)
        C++: virtual void SetFinalColorWindow(float _arg)
        
        Set the final color window. This controls the contrast of the
        image. The default value is 1.0. The Window can be negative (this
        causes a "negative" effect on the image) Although Window can be
        set to 0.0, any value less than 0.00001 and greater than or equal
        to 0.0 will be set to 0.00001, and any value greater than
        -0.00001 but less than or equal to 0.0 will be set to -0.00001.
        Initial value is 1.0.
        """
        ...
    
    def SetInteractiveAdjustSampleDistances(self, p_int):
        """
        V.SetInteractiveAdjustSampleDistances(int)
        C++: virtual void SetInteractiveAdjustSampleDistances(
            vtkTypeBool _arg)
        
        If the InteractiveAdjustSampleDistances flag is enabled,
        vtkSmartVolumeMapper interactively sets and resets the
        AutoAdjustSampleDistances flag on the internal volume mapper.
        This flag along with InteractiveUpdateRate is useful to adjust
        volume mapper sample distance based on whether the render is
        interactive or still. By default,
        InteractiveAdjustSampleDistances is enabled.
        """
        ...
    
    def SetInteractiveUpdateRate(self, p_float):
        """
        V.SetInteractiveUpdateRate(float)
        C++: virtual void SetInteractiveUpdateRate(double _arg)
        
        If the DesiredUpdateRate of the vtkRenderWindow that caused the
        Render falls at or above this rate, the render is considered
        interactive and the mapper may be adjusted (depending on the
        render mode). Initial value is 1.0.
        """
        ...
    
    def SetInterpolationMode(self, p_int):
        """
        V.SetInterpolationMode(int)
        C++: virtual void SetInterpolationMode(int _arg)
        
        Set interpolation mode for downsampling (lowres GPU) (initial
        value: cubic).
        """
        ...
    
    def SetInterpolationModeToCubic(self):
        """
        V.SetInterpolationModeToCubic()
        C++: void SetInterpolationModeToCubic()
        
        Set interpolation mode for downsampling (lowres GPU) (initial
        value: cubic).
        """
        ...
    
    def SetInterpolationModeToLinear(self):
        """
        V.SetInterpolationModeToLinear()
        C++: void SetInterpolationModeToLinear()
        
        Set interpolation mode for downsampling (lowres GPU) (initial
        value: cubic).
        """
        ...
    
    def SetInterpolationModeToNearestNeighbor(self):
        """
        V.SetInterpolationModeToNearestNeighbor()
        C++: void SetInterpolationModeToNearestNeighbor()
        
        Set interpolation mode for downsampling (lowres GPU) (initial
        value: cubic).
        """
        ...
    
    def SetMaxMemoryFraction(self, p_float):
        """
        V.SetMaxMemoryFraction(float)
        C++: virtual void SetMaxMemoryFraction(float _arg)
        
        Value passed to the GPU mapper. Ignored by other mappers. Maximum
        fraction of the MaxMemoryInBytes that should be used to hold the
        texture. Valid values are 0.1 to 1.0.
        """
        ...
    
    def SetMaxMemoryInBytes(self, p_int):
        """
        V.SetMaxMemoryInBytes(int)
        C++: virtual void SetMaxMemoryInBytes(vtkIdType _arg)
        
        Value passed to the GPU mapper. Ignored by other mappers. Maximum
        size of the 3D texture in GPU memory. Will default to the size
        computed from the graphics card. Can be adjusted by the user.
        Useful if the automatic detection is defective or missing.
        """
        ...
    
    def SetRequestedRenderMode(self, p_int):
        """
        V.SetRequestedRenderMode(int)
        C++: void SetRequestedRenderMode(int mode)
        
        Set the requested render mode. The default is
        vtkSmartVolumeMapper::DefaultRenderMode.
        """
        ...
    
    def SetRequestedRenderModeToDefault(self):
        """
        V.SetRequestedRenderModeToDefault()
        C++: void SetRequestedRenderModeToDefault()
        
        Set the requested render mode to
        vtkSmartVolumeMapper::DefaultRenderMode. This is the best option
        for an application that must adapt to different data types,
        hardware, and rendering parameters.
        """
        ...
    
    def SetRequestedRenderModeToGPU(self):
        """
        V.SetRequestedRenderModeToGPU()
        C++: void SetRequestedRenderModeToGPU()
        
        Set the requested render mode to
        vtkSmartVolumeMapper::GPURenderMode. This option will use
        hardware accelerated rendering exclusively. This is a good option
        if you know there is hardware acceleration.
        """
        ...
    
    def SetRequestedRenderModeToOSPRay(self):
        """
        V.SetRequestedRenderModeToOSPRay()
        C++: void SetRequestedRenderModeToOSPRay()
        
        Set the requested render mode to
        vtkSmartVolumeMapper::OSPRayRenderMode. This option will use
        intel OSPRay to do software rendering exclusively.
        """
        ...
    
    def SetRequestedRenderModeToRayCast(self):
        """
        V.SetRequestedRenderModeToRayCast()
        C++: void SetRequestedRenderModeToRayCast()
        
        Set the requested render mode to
        vtkSmartVolumeMapper::RayCastRenderMode. This option will use
        software rendering exclusively. This is a good option if you know
        there is no hardware acceleration.
        """
        ...
    
    def SetSampleDistance(self, p_float):
        """
        V.SetSampleDistance(float)
        C++: virtual void SetSampleDistance(float _arg)
        
        Set/Get the distance between samples used for rendering when
        AutoAdjustSampleDistances is off, or when this mapper has more
        than 1 second allocated to it for rendering. If SampleDistance is
        negative, it will be computed based on the dataset spacing.
        Initial value is -1.0.
        """
        ...
    
    def SetVectorComponent(self, p_int):
        """
        V.SetVectorComponent(int)
        C++: virtual void SetVectorComponent(int _arg)
        
        VectorMode is a special rendering mode for 3-component vectors
        which makes use of GPURayCastMapper's independent-component
        capabilities. In this mode, a single component in the vector can
        be selected for rendering. In addition, the mapper can compute a
        scalar field representing the magnitude of this vector using a
        vtkImageMagnitude object (MAGNITUDE mode).
        """
        ...
    
    def SetVectorMode(self, p_int):
        """
        V.SetVectorMode(int)
        C++: void SetVectorMode(int mode)
        
        VectorMode is a special rendering mode for 3-component vectors
        which makes use of GPURayCastMapper's independent-component
        capabilities. In this mode, a single component in the vector can
        be selected for rendering. In addition, the mapper can compute a
        scalar field representing the magnitude of this vector using a
        vtkImageMagnitude object (MAGNITUDE mode).
        """
        ...
    
    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__ = ...
    COMPONENT = ...
    DefaultRenderMode = ...
    DISABLED = ...
    GPURenderMode = ...
    InvalidRenderMode = ...
    MAGNITUDE = ...
    OSPRayRenderMode = ...
    RayCastRenderMode = ...
    UndefinedRenderMode = ...
    VectorModeType = ...
    __dict__ = ...
    __vtkname__ = ...


class vtkVolumeTexture(__vtkmodules_vtkCommonCore.vtkObject):
    """
    vtkVolumeTexture - Creates and manages the volume texture rendered by
    vtkOpenGLGPUVolumeRayCastMapper.
    
    Superclass: vtkObject
    
    Wraps a vtkTextureObject for which it selects the appropriate format
    (depending on the input vtkDataArray type, number of components,
    etc.) and loads input data. The class maintains a set of members of
    interest to the parent mapper, such as:
    
    * Active vtkDataArray scalar range.
    * Volume's scale and bias (pixel transfer functions).
    * HandleLargeDataType flag.
    * Texture to data transformations.
    * Block extents
    * Block loaded bounds
    
    This class supports streaming the volume data in separate blocks to
    make it fit in graphics memory (sometimes referred to as bricking).
    The data is split into a user-defined number of blocks in such a way
    that a single sub-block (brick) fits completely into GPU memory.  A
    stride is passed to OpenGL so that it can access the underlying
    vtkDataArray adequately for each of the blocks to be streamed into
    GPU memory (back-to-front for correct composition).
    
    Streaming the volume as separate texture bricks certainly imposes a
    performance trade-off but acts as a graphics memory expansion scheme
    for devices that would not be able to render higher resoulution
    volumes otherwise.
    
    @warning There are certain caveats when texture streaming is enabled,
    given
    the locality constraint that rendering a single block imposes.
    
    - Quality might suffer near the block seams with ShadeOn() (gradient
      computation at the boundaries needs adjustment).
    
    - Not all of the features supported by the mapper currently work
      correctly. This is a list of known issues:
    -# Blending modes such as average and additive might compute a
       different value near the edges.
    
    - Future work will extend the API to be able to compute an ideal
      number of partitions and extents based on the platform
      capabilities.
    
    @warning This is an internal class of
        vtkOpenGLGPUVolumeRayCastMapper. It
    assumes there is an active OpenGL context in methods involving GL
    calls (MakeCurrent() is expected to be called in the mapper
    beforehand).
    """
    def GetLoadedScalars(self):
        """
        V.GetLoadedScalars() -> vtkDataArray
        C++: vtkDataArray *GetLoadedScalars()
        """
        ...
    
    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 GetPartitions(self):
        """
        V.GetPartitions() -> vtkTuple_IiLi3EE
        C++: const Size3 &GetPartitions()
        """
        ...
    
    def GetScaleAndBias(self, p_int, *float, **kwargs):
        """
        V.GetScaleAndBias(int, [float, ...], float, float)
        C++: static void GetScaleAndBias(const int scalarType,
            float *scalarRange, float &scale, float &bias)
        
        Get the scale and bias values given a VTK scalar type and a
        finite range. The scale and bias values computed using this
        method can be useful for custom shader code. For example, when
        looking up color values through the transfer function texture,
        the scalar value must be scaled and offset.
        """
        ...
    
    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 LoadVolume(self, vtkRenderer, vtkImageData, vtkDataArray, p_int, p_int_1):
        """
        V.LoadVolume(vtkRenderer, vtkImageData, vtkDataArray, int, int)
            -> bool
        C++: bool LoadVolume(vtkRenderer *ren, vtkImageData *data,
            vtkDataArray *scalars, int const isCell,
            int const interpolation)
        
        Loads the data array into the texture in the case only a single
        block is is defined. Does not load when the input data is divided
        in multiple blocks (in which case they will be loaded into GPU
        memory by GetNextBlock()). Requires an active OpenGL context.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkVolumeTexture
        C++: vtkVolumeTexture *NewInstance()
        """
        ...
    
    def ReleaseGraphicsResources(self, vtkWindow):
        """
        V.ReleaseGraphicsResources(vtkWindow)
        C++: void ReleaseGraphicsResources(vtkWindow *win)
        
        Clean-up acquired graphics resources.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkVolumeTexture
        C++: static vtkVolumeTexture *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def SetPartitions(self, p_int, p_int_1, p_int_2):
        """
        V.SetPartitions(int, int, int)
        C++: void SetPartitions(int const i, int const j, int const k)
        
        Set a number of blocks per axis.
        """
        ...
    
    def SortBlocksBackToFront(self, vtkRenderer, vtkMatrix4x4):
        """
        V.SortBlocksBackToFront(vtkRenderer, vtkMatrix4x4)
        C++: void SortBlocksBackToFront(vtkRenderer *ren,
            vtkMatrix4x4 *volumeMat)
        
        If streaming the data array as separate blocks, sort them back to
        front. This method does nothing if there is a single block.
        """
        ...
    
    def UpdateVolume(self, vtkVolumeProperty):
        """
        V.UpdateVolume(vtkVolumeProperty)
        C++: void UpdateVolume(vtkVolumeProperty *property)
        
        It currently only calls SetInterpolation internally. Requires an
        active OpenGL context.
        """
        ...
    
    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__ = ...


__loader__ = ...
__spec__ = ...
