# encoding: utf-8
# module vtkmodules.vtkRenderingVolume
# from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\vtkmodules\vtkRenderingVolume.cp311-win_amd64.pyd
# by generator 1.147
# no doc

# imports
import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore
import vtkmodules.vtkCommonExecutionModel as __vtkmodules_vtkCommonExecutionModel
import vtkmodules.vtkRenderingCore as __vtkmodules_vtkRenderingCore


from .vtkVolumeMapper import vtkVolumeMapper

class vtkFixedPointVolumeRayCastMapper(vtkVolumeMapper):
    """
    vtkFixedPointVolumeRayCastMapper - A fixed point mapper for volumes
    
    Superclass: vtkVolumeMapper
    
    This is a software ray caster for rendering volumes in vtkImageData.
    It works with all input data types and up to four components. It
    performs composite or MIP rendering, and can be intermixed with
    geometric data. Space leaping is used to speed up the rendering
    process. In addition, calculation are performed in 15 bit fixed point
    precision. This mapper is threaded, and will interleave scan lines
    across processors.
    
    WARNING: This ray caster may not produce consistent results when the
    number of threads exceeds 1. The class warns if the number of threads
    > 1. The differences may be subtle. Applications should decide if the
    trade-off in performance is worth the lack of consistency.
    
    Other limitations of this ray caster include that:
    - it does not do isosurface ray casting
    - it does only interpolate before classify compositing
    - it does only maximum scalar value MIP
    
    This mapper handles all data type from unsigned char through double.
    However, some of the internal calcultions are performed in float and
    therefore even the full float range may cause problems for this
    mapper (both in scalar data values and in spacing between samples).
    
    Space leaping is performed by creating a sub-sampled volume. 4x4x4
    cells in the original volume are represented by a min, max, and
    combined gradient and flag value. The min max volume has three
    unsigned shorts per 4x4x4 group of cells from the original volume -
    one representing the minimum scalar index (the scalar value adjusted
    to fit in the 15 bit range), the maximum scalar index, and a third
    unsigned short which is both the maximum gradient opacity in the
    neighborhood (an unsigned char) and the flag that is filled in for
    the current lookup tables to indicate whether this region can be
    skipped.
    
    @sa
    vtkVolumeMapper
    """
    def AbortRender(self): # real signature unknown; restored from __doc__
        """
        AbortRender(self) -> None
        C++: void AbortRender()
        """
        pass

    def AutoAdjustSampleDistancesOff(self): # real signature unknown; restored from __doc__
        """
        AutoAdjustSampleDistancesOff(self) -> None
        C++: virtual void AutoAdjustSampleDistancesOff()
        """
        pass

    def AutoAdjustSampleDistancesOn(self): # real signature unknown; restored from __doc__
        """
        AutoAdjustSampleDistancesOn(self) -> None
        C++: virtual void AutoAdjustSampleDistancesOn()
        """
        pass

    def CheckIfCropped(self, pos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        CheckIfCropped(self, pos:[int, int, int]) -> int
        C++: int CheckIfCropped(unsigned int pos[3])
        """
        pass

    def CheckMinMaxVolumeFlag(self, pos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        CheckMinMaxVolumeFlag(self, pos:[int, int, int], c:int) -> int
        C++: int CheckMinMaxVolumeFlag(unsigned int pos[3], int c)
        """
        pass

    def CheckMIPMinMaxVolumeFlag(self, pos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        CheckMIPMinMaxVolumeFlag(self, pos:[int, int, int], c:int,
            maxIdx:int, flip:int) -> int
        C++: int CheckMIPMinMaxVolumeFlag(unsigned int pos[3], int c,
            unsigned short maxIdx, int flip)
        """
        pass

    def ComputeRayInfo(self, x, y, pos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        ComputeRayInfo(self, x:int, y:int, pos:[int, int, int], dir:[int,
            int, int], numSteps:[int, ...]) -> None
        C++: void ComputeRayInfo(int x, int y, unsigned int pos[3],
            unsigned int dir[3], unsigned int *numSteps)
        """
        pass

    def ComputeRequiredImageSampleDistance(self, desiredTime, ren): # real signature unknown; restored from __doc__
        """
        ComputeRequiredImageSampleDistance(self, desiredTime:float,
            ren:vtkRenderer) -> float
        C++: float ComputeRequiredImageSampleDistance(float desiredTime,
            vtkRenderer *ren)
        ComputeRequiredImageSampleDistance(self, desiredTime:float,
            ren:vtkRenderer, vol:vtkVolume) -> float
        C++: float ComputeRequiredImageSampleDistance(float desiredTime,
            vtkRenderer *ren, vtkVolume *vol)
        
        What is the image sample distance required to achieve the desired
        time? A version of this method is provided that does not require
        the volume argument since if you are using an LODProp3D you may
        not know this information. If you use this version you must be
        certain that the ray cast mapper is only used for one volume (and
        not shared among multiple volumes)
        """
        return 0.0

    def CreateCanonicalView(self, volume, image, blend_mode, viewDirection, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        CreateCanonicalView(self, volume:vtkVolume, image:vtkImageData,
            blend_mode:int, viewDirection:[float, float, float],
            viewUp:[float, float, float]) -> None
        C++: void CreateCanonicalView(vtkVolume *volume,
            vtkImageData *image, int blend_mode, double viewDirection[3],
            double viewUp[3])
        """
        pass

    def DisplayRenderedImage(self, __a, __b): # real signature unknown; restored from __doc__
        """
        DisplayRenderedImage(self, __a:vtkRenderer, __b:vtkVolume) -> None
        C++: void DisplayRenderedImage(vtkRenderer *, vtkVolume *)
        """
        pass

    def FixedPointIncrement(self, position, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        FixedPointIncrement(self, position:[int, int, int],
            increment:[int, int, int]) -> None
        C++: void FixedPointIncrement(unsigned int position[3],
            unsigned int increment[3])
        """
        pass

    def GetAutoAdjustSampleDistances(self): # real signature unknown; restored from __doc__
        """
        GetAutoAdjustSampleDistances(self) -> int
        C++: virtual vtkTypeBool GetAutoAdjustSampleDistances()
        """
        return 0

    def GetAutoAdjustSampleDistancesMaxValue(self): # real signature unknown; restored from __doc__
        """
        GetAutoAdjustSampleDistancesMaxValue(self) -> int
        C++: virtual vtkTypeBool GetAutoAdjustSampleDistancesMaxValue()
        """
        return 0

    def GetAutoAdjustSampleDistancesMinValue(self): # real signature unknown; restored from __doc__
        """
        GetAutoAdjustSampleDistancesMinValue(self) -> int
        C++: virtual vtkTypeBool GetAutoAdjustSampleDistancesMinValue()
        """
        return 0

    def GetColorTable(self, c): # real signature unknown; restored from __doc__
        """
        GetColorTable(self, c:int) -> Pointer
        C++: unsigned short *GetColorTable(int c)
        """
        pass

    def GetCompositeGOHelper(self): # real signature unknown; restored from __doc__
        """
        GetCompositeGOHelper(self)
            -> vtkFixedPointVolumeRayCastCompositeGOHelper
        C++: virtual vtkFixedPointVolumeRayCastCompositeGOHelper *GetCompositeGOHelper(
            )
        """
        return vtkFixedPointVolumeRayCastCompositeGOHelper

    def GetCompositeGOShadeHelper(self): # real signature unknown; restored from __doc__
        """
        GetCompositeGOShadeHelper(self)
            -> vtkFixedPointVolumeRayCastCompositeGOShadeHelper
        C++: virtual vtkFixedPointVolumeRayCastCompositeGOShadeHelper *GetCompositeGOShadeHelper(
            )
        """
        return vtkFixedPointVolumeRayCastCompositeGOShadeHelper

    def GetCompositeHelper(self): # real signature unknown; restored from __doc__
        """
        GetCompositeHelper(self)
            -> vtkFixedPointVolumeRayCastCompositeHelper
        C++: virtual vtkFixedPointVolumeRayCastCompositeHelper *GetCompositeHelper(
            )
        """
        return vtkFixedPointVolumeRayCastCompositeHelper

    def GetCompositeShadeHelper(self): # real signature unknown; restored from __doc__
        """
        GetCompositeShadeHelper(self)
            -> vtkFixedPointVolumeRayCastCompositeShadeHelper
        C++: virtual vtkFixedPointVolumeRayCastCompositeShadeHelper *GetCompositeShadeHelper(
            )
        """
        return vtkFixedPointVolumeRayCastCompositeShadeHelper

    def GetCurrentScalars(self): # real signature unknown; restored from __doc__
        """
        GetCurrentScalars(self) -> vtkDataArray
        C++: virtual vtkDataArray *GetCurrentScalars()
        """
        pass

    def GetDiffuseShadingTable(self, c): # real signature unknown; restored from __doc__
        """
        GetDiffuseShadingTable(self, c:int) -> Pointer
        C++: unsigned short *GetDiffuseShadingTable(int c)
        """
        pass

    def GetEstimatedRenderTime(self, ren, vol): # real signature unknown; restored from __doc__
        """
        GetEstimatedRenderTime(self, ren:vtkRenderer, vol:vtkVolume)
            -> float
        C++: float GetEstimatedRenderTime(vtkRenderer *ren,
            vtkVolume *vol)
        GetEstimatedRenderTime(self, ren:vtkRenderer) -> float
        C++: float GetEstimatedRenderTime(vtkRenderer *ren)
        
        Get an estimate of the rendering time for a given volume /
        renderer. Only valid if this mapper has been used to render that
        volume for that renderer previously. Estimate is good when the
        viewing parameters have not changed much since that last render.
        """
        return 0.0

    def GetFinalColorLevel(self): # real signature unknown; restored from __doc__
        """
        GetFinalColorLevel(self) -> float
        C++: virtual float GetFinalColorLevel()
        """
        return 0.0

    def GetFinalColorWindow(self): # real signature unknown; restored from __doc__
        """
        GetFinalColorWindow(self) -> float
        C++: virtual float GetFinalColorWindow()
        """
        return 0.0

    def GetFlipMIPComparison(self): # real signature unknown; restored from __doc__
        """
        GetFlipMIPComparison(self) -> int
        C++: virtual int GetFlipMIPComparison()
        """
        return 0

    def GetFloatTripleFromPointer(self, v, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetFloatTripleFromPointer(self, v:[float, float, float],
            ptr:[float, ...]) -> None
        C++: void GetFloatTripleFromPointer(float v[3], float *ptr)
        """
        pass

    def GetGradientOpacityRequired(self): # real signature unknown; restored from __doc__
        """
        GetGradientOpacityRequired(self) -> int
        C++: virtual int GetGradientOpacityRequired()
        """
        return 0

    def GetGradientOpacityTable(self, c): # real signature unknown; restored from __doc__
        """
        GetGradientOpacityTable(self, c:int) -> Pointer
        C++: unsigned short *GetGradientOpacityTable(int c)
        """
        pass

    def GetImageSampleDistance(self): # real signature unknown; restored from __doc__
        """
        GetImageSampleDistance(self) -> float
        C++: virtual float GetImageSampleDistance()
        """
        return 0.0

    def GetImageSampleDistanceMaxValue(self): # real signature unknown; restored from __doc__
        """
        GetImageSampleDistanceMaxValue(self) -> float
        C++: virtual float GetImageSampleDistanceMaxValue()
        """
        return 0.0

    def GetImageSampleDistanceMinValue(self): # real signature unknown; restored from __doc__
        """
        GetImageSampleDistanceMinValue(self) -> float
        C++: virtual float GetImageSampleDistanceMinValue()
        """
        return 0.0

    def GetInteractiveSampleDistance(self): # real signature unknown; restored from __doc__
        """
        GetInteractiveSampleDistance(self) -> float
        C++: virtual float GetInteractiveSampleDistance()
        """
        return 0.0

    def GetIntermixIntersectingGeometry(self): # real signature unknown; restored from __doc__
        """
        GetIntermixIntersectingGeometry(self) -> int
        C++: virtual vtkTypeBool GetIntermixIntersectingGeometry()
        """
        return 0

    def GetIntermixIntersectingGeometryMaxValue(self): # real signature unknown; restored from __doc__
        """
        GetIntermixIntersectingGeometryMaxValue(self) -> int
        C++: virtual vtkTypeBool GetIntermixIntersectingGeometryMaxValue()
        """
        return 0

    def GetIntermixIntersectingGeometryMinValue(self): # real signature unknown; restored from __doc__
        """
        GetIntermixIntersectingGeometryMinValue(self) -> int
        C++: virtual vtkTypeBool GetIntermixIntersectingGeometryMinValue()
        """
        return 0

    def GetLockSampleDistanceToInputSpacing(self): # real signature unknown; restored from __doc__
        """
        GetLockSampleDistanceToInputSpacing(self) -> int
        C++: virtual vtkTypeBool GetLockSampleDistanceToInputSpacing()
        """
        return 0

    def GetLockSampleDistanceToInputSpacingMaxValue(self): # real signature unknown; restored from __doc__
        """
        GetLockSampleDistanceToInputSpacingMaxValue(self) -> int
        C++: virtual vtkTypeBool GetLockSampleDistanceToInputSpacingMaxValue(
            )
        """
        return 0

    def GetLockSampleDistanceToInputSpacingMinValue(self): # real signature unknown; restored from __doc__
        """
        GetLockSampleDistanceToInputSpacingMinValue(self) -> int
        C++: virtual vtkTypeBool GetLockSampleDistanceToInputSpacingMinValue(
            )
        """
        return 0

    def GetMaximumImageSampleDistance(self): # real signature unknown; restored from __doc__
        """
        GetMaximumImageSampleDistance(self) -> float
        C++: virtual float GetMaximumImageSampleDistance()
        """
        return 0.0

    def GetMaximumImageSampleDistanceMaxValue(self): # real signature unknown; restored from __doc__
        """
        GetMaximumImageSampleDistanceMaxValue(self) -> float
        C++: virtual float GetMaximumImageSampleDistanceMaxValue()
        """
        return 0.0

    def GetMaximumImageSampleDistanceMinValue(self): # real signature unknown; restored from __doc__
        """
        GetMaximumImageSampleDistanceMinValue(self) -> float
        C++: virtual float GetMaximumImageSampleDistanceMinValue()
        """
        return 0.0

    def GetMinimumImageSampleDistance(self): # real signature unknown; restored from __doc__
        """
        GetMinimumImageSampleDistance(self) -> float
        C++: virtual float GetMinimumImageSampleDistance()
        """
        return 0.0

    def GetMinimumImageSampleDistanceMaxValue(self): # real signature unknown; restored from __doc__
        """
        GetMinimumImageSampleDistanceMaxValue(self) -> float
        C++: virtual float GetMinimumImageSampleDistanceMaxValue()
        """
        return 0.0

    def GetMinimumImageSampleDistanceMinValue(self): # real signature unknown; restored from __doc__
        """
        GetMinimumImageSampleDistanceMinValue(self) -> float
        C++: virtual float GetMinimumImageSampleDistanceMinValue()
        """
        return 0.0

    def GetMIPHelper(self): # real signature unknown; restored from __doc__
        """
        GetMIPHelper(self) -> vtkFixedPointVolumeRayCastMIPHelper
        C++: virtual vtkFixedPointVolumeRayCastMIPHelper *GetMIPHelper()
        """
        return vtkFixedPointVolumeRayCastMIPHelper

    def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBase(self, type:str) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given 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.
        """
        return 0

    def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBaseType(type:str) -> 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.
        """
        return 0

    def GetNumberOfThreads(self): # real signature unknown; restored from __doc__
        """
        GetNumberOfThreads(self) -> int
        C++: int GetNumberOfThreads()
        """
        return 0

    def GetPreviousScalars(self): # real signature unknown; restored from __doc__
        """
        GetPreviousScalars(self) -> vtkDataArray
        C++: virtual vtkDataArray *GetPreviousScalars()
        """
        pass

    def GetRayCastImage(self): # real signature unknown; restored from __doc__
        """
        GetRayCastImage(self) -> vtkFixedPointRayCastImage
        C++: virtual vtkFixedPointRayCastImage *GetRayCastImage()
        """
        return vtkFixedPointRayCastImage

    def GetRenderWindow(self): # real signature unknown; restored from __doc__
        """
        GetRenderWindow(self) -> vtkRenderWindow
        C++: virtual vtkRenderWindow *GetRenderWindow()
        """
        pass

    def GetRowBounds(self): # real signature unknown; restored from __doc__
        """
        GetRowBounds(self) -> Pointer
        C++: int *GetRowBounds()
        """
        pass

    def GetSampleDistance(self): # real signature unknown; restored from __doc__
        """
        GetSampleDistance(self) -> float
        C++: virtual float GetSampleDistance()
        """
        return 0.0

    def GetScalarOpacityTable(self, c): # real signature unknown; restored from __doc__
        """
        GetScalarOpacityTable(self, c:int) -> Pointer
        C++: unsigned short *GetScalarOpacityTable(int c)
        """
        pass

    def GetShadingRequired(self): # real signature unknown; restored from __doc__
        """
        GetShadingRequired(self) -> int
        C++: virtual int GetShadingRequired()
        """
        return 0

    def GetSpecularShadingTable(self, c): # real signature unknown; restored from __doc__
        """
        GetSpecularShadingTable(self, c:int) -> Pointer
        C++: unsigned short *GetSpecularShadingTable(int c)
        """
        pass

    def GetTableScale(self): # real signature unknown; restored from __doc__
        """
        GetTableScale(self) -> (float, float, float, float)
        C++: virtual float *GetTableScale()
        """
        pass

    def GetTableShift(self): # real signature unknown; restored from __doc__
        """
        GetTableShift(self) -> (float, float, float, float)
        C++: virtual float *GetTableShift()
        """
        pass

    def GetUIntTripleFromPointer(self, v, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetUIntTripleFromPointer(self, v:[int, int, int], ptr:[int, ...])
            -> None
        C++: void GetUIntTripleFromPointer(unsigned int v[3],
            unsigned int *ptr)
        """
        pass

    def GetVolume(self): # real signature unknown; restored from __doc__
        """
        GetVolume(self) -> vtkVolume
        C++: vtkVolume *GetVolume()
        """
        pass

    def InitializeRayInfo(self, vol): # real signature unknown; restored from __doc__
        """
        InitializeRayInfo(self, vol:vtkVolume) -> None
        C++: void InitializeRayInfo(vtkVolume *vol)
        """
        pass

    def IntermixIntersectingGeometryOff(self): # real signature unknown; restored from __doc__
        """
        IntermixIntersectingGeometryOff(self) -> None
        C++: virtual void IntermixIntersectingGeometryOff()
        """
        pass

    def IntermixIntersectingGeometryOn(self): # real signature unknown; restored from __doc__
        """
        IntermixIntersectingGeometryOn(self) -> None
        C++: virtual void IntermixIntersectingGeometryOn()
        """
        pass

    def IsA(self, type): # real signature unknown; restored from __doc__
        """
        IsA(self, type:str) -> 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.
        """
        return 0

    def IsTypeOf(self, type): # real signature unknown; restored from __doc__
        """
        IsTypeOf(type:str) -> 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.
        """
        return 0

    def LockSampleDistanceToInputSpacingOff(self): # real signature unknown; restored from __doc__
        """
        LockSampleDistanceToInputSpacingOff(self) -> None
        C++: virtual void LockSampleDistanceToInputSpacingOff()
        """
        pass

    def LockSampleDistanceToInputSpacingOn(self): # real signature unknown; restored from __doc__
        """
        LockSampleDistanceToInputSpacingOn(self) -> None
        C++: virtual void LockSampleDistanceToInputSpacingOn()
        """
        pass

    def LookupColorUC(self, colorTable, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        LookupColorUC(self, colorTable:[int, ...],
            scalarOpacityTable:[int, ...], index:int, color:[int, int,
            int, int]) -> None
        C++: void LookupColorUC(unsigned short *colorTable,
            unsigned short *scalarOpacityTable, unsigned short index,
            unsigned char color[4])
        """
        pass

    def LookupDependentColorUC(self, colorTable, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        LookupDependentColorUC(self, colorTable:[int, ...],
            scalarOpacityTable:[int, ...], index:[int, int, int, int],
            components:int, color:[int, int, int, int]) -> None
        C++: void LookupDependentColorUC(unsigned short *colorTable,
            unsigned short *scalarOpacityTable, unsigned short index[4],
            int components, unsigned char color[4])
        """
        pass

    def NewInstance(self): # real signature unknown; restored from __doc__
        """
        NewInstance(self) -> vtkFixedPointVolumeRayCastMapper
        C++: vtkFixedPointVolumeRayCastMapper *NewInstance()
        """
        return vtkFixedPointVolumeRayCastMapper

    def PerImageInitialization(self, __a, __b, __c, __d, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        PerImageInitialization(self, __a:vtkRenderer, __b:vtkVolume,
            __c:int, __d:[float, ...], __e:[float, ...], __f:[int, ...])
            -> int
        C++: int PerImageInitialization(vtkRenderer *, vtkVolume *, int,
            double *, double *, int *)
        """
        pass

    def PerSubVolumeInitialization(self, __a, __b, __c): # real signature unknown; restored from __doc__
        """
        PerSubVolumeInitialization(self, __a:vtkRenderer, __b:vtkVolume,
            __c:int) -> None
        C++: void PerSubVolumeInitialization(vtkRenderer *, vtkVolume *,
            int)
        """
        pass

    def PerVolumeInitialization(self, __a, __b): # real signature unknown; restored from __doc__
        """
        PerVolumeInitialization(self, __a:vtkRenderer, __b:vtkVolume)
            -> None
        C++: void PerVolumeInitialization(vtkRenderer *, vtkVolume *)
        """
        pass

    def ReleaseGraphicsResources(self, __a): # real signature unknown; restored from __doc__
        """
        ReleaseGraphicsResources(self, __a:vtkWindow) -> None
        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.
        """
        pass

    def Render(self, __a, __b): # real signature unknown; restored from __doc__
        """
        Render(self, __a:vtkRenderer, __b:vtkVolume) -> None
        C++: void Render(vtkRenderer *, vtkVolume *) override;
        
        WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE
        Initialize rendering for this volume.
        """
        pass

    def RenderSubVolume(self): # real signature unknown; restored from __doc__
        """
        RenderSubVolume(self) -> None
        C++: void RenderSubVolume()
        """
        pass

    def SafeDownCast(self, o): # real signature unknown; restored from __doc__
        """
        SafeDownCast(o:vtkObjectBase) -> vtkFixedPointVolumeRayCastMapper
        C++: static vtkFixedPointVolumeRayCastMapper *SafeDownCast(
            vtkObjectBase *o)
        """
        return vtkFixedPointVolumeRayCastMapper

    def SetAutoAdjustSampleDistances(self, _arg): # real signature unknown; restored from __doc__
        """
        SetAutoAdjustSampleDistances(self, _arg:int) -> None
        C++: virtual void SetAutoAdjustSampleDistances(vtkTypeBool _arg)
        
        If AutoAdjustSampleDistances is on, the ImageSampleDistance and
        the SampleDistance will be varied to achieve the allocated render
        time of this prop (controlled by the desired update rate and any
        culling in use). If this is an interactive render (more than 1
        frame per second) the SampleDistance will be increased, otherwise
        it will not be altered (a binary decision, as opposed to the
        ImageSampleDistance which will vary continuously).
        """
        pass

    def SetFinalColorLevel(self, _arg): # real signature unknown; restored from __doc__
        """
        SetFinalColorLevel(self, _arg:float) -> None
        C++: virtual void SetFinalColorLevel(float _arg)
        """
        pass

    def SetFinalColorWindow(self, _arg): # real signature unknown; restored from __doc__
        """
        SetFinalColorWindow(self, _arg:float) -> None
        C++: virtual void SetFinalColorWindow(float _arg)
        
        Set/Get the window / level applied to the final color. This
        allows brightness / contrast adjustments on the final image.
        window is the width of the window. level is the center of the
        window. Initial window value is 1.0 Initial level value is 0.5
        window cannot be null but can be negative, this way values will
        be reversed. |window| can be larger than 1.0 level can be any
        real value.
        """
        pass

    def SetImageSampleDistance(self, _arg): # real signature unknown; restored from __doc__
        """
        SetImageSampleDistance(self, _arg:float) -> None
        C++: virtual void SetImageSampleDistance(float _arg)
        
        Sampling distance in the XY image dimensions. Default value of 1
        meaning 1 ray cast per pixel. If set to 0.5, 4 rays will be cast
        per pixel. If set to 2.0, 1 ray will be cast for every 4 (2 by 2)
        pixels. This value will be adjusted to meet a desired frame rate
        when AutoAdjustSampleDistances is on.
        """
        pass

    def SetInteractiveSampleDistance(self, _arg): # real signature unknown; restored from __doc__
        """
        SetInteractiveSampleDistance(self, _arg:float) -> None
        C++: virtual void SetInteractiveSampleDistance(float _arg)
        
        Set/Get the distance between samples when interactive rendering
        is happening. In this case, interactive is defined as this volume
        mapper having less than 1 second allocated for rendering. When
        AutoAdjustSampleDistance is On, and the allocated render time is
        less than 1 second, then this InteractiveSampleDistance will be
        used instead of the SampleDistance above.
        """
        pass

    def SetIntermixIntersectingGeometry(self, _arg): # real signature unknown; restored from __doc__
        """
        SetIntermixIntersectingGeometry(self, _arg:int) -> None
        C++: virtual void SetIntermixIntersectingGeometry(
            vtkTypeBool _arg)
        
        If IntermixIntersectingGeometry is turned on, the zbuffer will be
        captured and used to limit the traversal of the rays.
        """
        pass

    def SetLockSampleDistanceToInputSpacing(self, _arg): # real signature unknown; restored from __doc__
        """
        SetLockSampleDistanceToInputSpacing(self, _arg:int) -> None
        C++: virtual void SetLockSampleDistanceToInputSpacing(
            vtkTypeBool _arg)
        
        Automatically compute the sample distance from the data spacing. 
        When the number of voxels is 8, the sample distance will be
        roughly 1/200 the average voxel size. The distance will grow
        proportionally to numVoxels^(1/3) until it reaches 1/2 average
        voxel size when number of voxels is 1E6. Note that
        ScalarOpacityUnitDistance is still taken into account and if
        different than 1, will effect the sample distance.
        """
        pass

    def SetMaximumImageSampleDistance(self, _arg): # real signature unknown; restored from __doc__
        """
        SetMaximumImageSampleDistance(self, _arg:float) -> None
        C++: virtual void SetMaximumImageSampleDistance(float _arg)
        
        This is the maximum image sample distance allow when the image
        sample distance is being automatically adjusted.
        """
        pass

    def SetMinimumImageSampleDistance(self, _arg): # real signature unknown; restored from __doc__
        """
        SetMinimumImageSampleDistance(self, _arg:float) -> None
        C++: virtual void SetMinimumImageSampleDistance(float _arg)
        
        This is the minimum image sample distance allow when the image
        sample distance is being automatically adjusted.
        """
        pass

    def SetNumberOfThreads(self, num): # real signature unknown; restored from __doc__
        """
        SetNumberOfThreads(self, num:int) -> None
        C++: void SetNumberOfThreads(int num)
        
        Set/Get the number of threads to use. This by default is equal to
        the number of available processors detected. WARNING: If number
        of threads > 1, results may not be consistent.
        """
        pass

    def SetRayCastImage(self, __a): # real signature unknown; restored from __doc__
        """
        SetRayCastImage(self, __a:vtkFixedPointRayCastImage) -> None
        C++: void SetRayCastImage(vtkFixedPointRayCastImage *)
        
        Set / Get the underlying image object. One will be automatically
        created - only need to set it when using from an AMR mapper which
        renders multiple times into the same image.
        """
        pass

    def SetSampleDistance(self, _arg): # real signature unknown; restored from __doc__
        """
        SetSampleDistance(self, _arg:float) -> None
        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.
        """
        pass

    def ShiftVectorDown(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        ShiftVectorDown(self, in_:[int, int, int], out:[int, int, int])
            -> None
        C++: void ShiftVectorDown(unsigned int in[3], unsigned int out[3])
        """
        pass

    def ShouldUseNearestNeighborInterpolation(self, vol): # real signature unknown; restored from __doc__
        """
        ShouldUseNearestNeighborInterpolation(self, vol:vtkVolume) -> int
        C++: int ShouldUseNearestNeighborInterpolation(vtkVolume *vol)
        """
        return 0

    def ToFixedPointDirection(self, dir): # real signature unknown; restored from __doc__
        """
        ToFixedPointDirection(self, dir:float) -> int
        C++: unsigned int ToFixedPointDirection(float dir)
        ToFixedPointDirection(self, in_:[float, float, float], out:[int,
            int, int]) -> None
        C++: void ToFixedPointDirection(float in[3], unsigned int out[3])
        """
        return 0

    def ToFixedPointPosition(self, val): # real signature unknown; restored from __doc__
        """
        ToFixedPointPosition(self, val:float) -> int
        C++: unsigned int ToFixedPointPosition(float val)
        ToFixedPointPosition(self, in_:[float, float, float], out:[int,
            int, int]) -> None
        C++: void ToFixedPointPosition(float in[3], unsigned int out[3])
        """
        return 0

    def __delattr__(self, *args, **kwargs): # real signature unknown
        """ Implement delattr(self, name). """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setattr__(self, *args, **kwargs): # real signature unknown
        """ Implement setattr(self, name, value). """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass

    __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Pointer to the C++ object."""


    __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkFixedPointVolumeRayCastMapper', 'IsTypeOf': <method 'IsTypeOf' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'IsA': <method 'IsA' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'SafeDownCast': <method 'SafeDownCast' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'NewInstance': <method 'NewInstance' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetNumberOfGenerationsFromBaseType': <method 'GetNumberOfGenerationsFromBaseType' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetNumberOfGenerationsFromBase': <method 'GetNumberOfGenerationsFromBase' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'SetSampleDistance': <method 'SetSampleDistance' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetSampleDistance': <method 'GetSampleDistance' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'SetInteractiveSampleDistance': <method 'SetInteractiveSampleDistance' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetInteractiveSampleDistance': <method 'GetInteractiveSampleDistance' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'SetImageSampleDistance': <method 'SetImageSampleDistance' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetImageSampleDistanceMinValue': <method 'GetImageSampleDistanceMinValue' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetImageSampleDistanceMaxValue': <method 'GetImageSampleDistanceMaxValue' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetImageSampleDistance': <method 'GetImageSampleDistance' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'SetMinimumImageSampleDistance': <method 'SetMinimumImageSampleDistance' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetMinimumImageSampleDistanceMinValue': <method 'GetMinimumImageSampleDistanceMinValue' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetMinimumImageSampleDistanceMaxValue': <method 'GetMinimumImageSampleDistanceMaxValue' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetMinimumImageSampleDistance': <method 'GetMinimumImageSampleDistance' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'SetMaximumImageSampleDistance': <method 'SetMaximumImageSampleDistance' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetMaximumImageSampleDistanceMinValue': <method 'GetMaximumImageSampleDistanceMinValue' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetMaximumImageSampleDistanceMaxValue': <method 'GetMaximumImageSampleDistanceMaxValue' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetMaximumImageSampleDistance': <method 'GetMaximumImageSampleDistance' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'SetAutoAdjustSampleDistances': <method 'SetAutoAdjustSampleDistances' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetAutoAdjustSampleDistancesMinValue': <method 'GetAutoAdjustSampleDistancesMinValue' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetAutoAdjustSampleDistancesMaxValue': <method 'GetAutoAdjustSampleDistancesMaxValue' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetAutoAdjustSampleDistances': <method 'GetAutoAdjustSampleDistances' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'AutoAdjustSampleDistancesOn': <method 'AutoAdjustSampleDistancesOn' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'AutoAdjustSampleDistancesOff': <method 'AutoAdjustSampleDistancesOff' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'SetLockSampleDistanceToInputSpacing': <method 'SetLockSampleDistanceToInputSpacing' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetLockSampleDistanceToInputSpacingMinValue': <method 'GetLockSampleDistanceToInputSpacingMinValue' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetLockSampleDistanceToInputSpacingMaxValue': <method 'GetLockSampleDistanceToInputSpacingMaxValue' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetLockSampleDistanceToInputSpacing': <method 'GetLockSampleDistanceToInputSpacing' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'LockSampleDistanceToInputSpacingOn': <method 'LockSampleDistanceToInputSpacingOn' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'LockSampleDistanceToInputSpacingOff': <method 'LockSampleDistanceToInputSpacingOff' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'SetNumberOfThreads': <method 'SetNumberOfThreads' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetNumberOfThreads': <method 'GetNumberOfThreads' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'SetIntermixIntersectingGeometry': <method 'SetIntermixIntersectingGeometry' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetIntermixIntersectingGeometryMinValue': <method 'GetIntermixIntersectingGeometryMinValue' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetIntermixIntersectingGeometryMaxValue': <method 'GetIntermixIntersectingGeometryMaxValue' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetIntermixIntersectingGeometry': <method 'GetIntermixIntersectingGeometry' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'IntermixIntersectingGeometryOn': <method 'IntermixIntersectingGeometryOn' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'IntermixIntersectingGeometryOff': <method 'IntermixIntersectingGeometryOff' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'ComputeRequiredImageSampleDistance': <method 'ComputeRequiredImageSampleDistance' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'Render': <method 'Render' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'ToFixedPointPosition': <method 'ToFixedPointPosition' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'ToFixedPointDirection': <method 'ToFixedPointDirection' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'FixedPointIncrement': <method 'FixedPointIncrement' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetFloatTripleFromPointer': <method 'GetFloatTripleFromPointer' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetUIntTripleFromPointer': <method 'GetUIntTripleFromPointer' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'ShiftVectorDown': <method 'ShiftVectorDown' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'CheckMinMaxVolumeFlag': <method 'CheckMinMaxVolumeFlag' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'CheckMIPMinMaxVolumeFlag': <method 'CheckMIPMinMaxVolumeFlag' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'LookupColorUC': <method 'LookupColorUC' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'LookupDependentColorUC': <method 'LookupDependentColorUC' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'CheckIfCropped': <method 'CheckIfCropped' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetRenderWindow': <method 'GetRenderWindow' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetMIPHelper': <method 'GetMIPHelper' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetCompositeHelper': <method 'GetCompositeHelper' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetCompositeGOHelper': <method 'GetCompositeGOHelper' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetCompositeGOShadeHelper': <method 'GetCompositeGOShadeHelper' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetCompositeShadeHelper': <method 'GetCompositeShadeHelper' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetTableShift': <method 'GetTableShift' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetTableScale': <method 'GetTableScale' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetShadingRequired': <method 'GetShadingRequired' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetGradientOpacityRequired': <method 'GetGradientOpacityRequired' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetCurrentScalars': <method 'GetCurrentScalars' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetPreviousScalars': <method 'GetPreviousScalars' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetRowBounds': <method 'GetRowBounds' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetColorTable': <method 'GetColorTable' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetScalarOpacityTable': <method 'GetScalarOpacityTable' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetGradientOpacityTable': <method 'GetGradientOpacityTable' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetVolume': <method 'GetVolume' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetDiffuseShadingTable': <method 'GetDiffuseShadingTable' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetSpecularShadingTable': <method 'GetSpecularShadingTable' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'ComputeRayInfo': <method 'ComputeRayInfo' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'InitializeRayInfo': <method 'InitializeRayInfo' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'ShouldUseNearestNeighborInterpolation': <method 'ShouldUseNearestNeighborInterpolation' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'SetRayCastImage': <method 'SetRayCastImage' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetRayCastImage': <method 'GetRayCastImage' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'PerImageInitialization': <method 'PerImageInitialization' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'PerVolumeInitialization': <method 'PerVolumeInitialization' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'PerSubVolumeInitialization': <method 'PerSubVolumeInitialization' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'RenderSubVolume': <method 'RenderSubVolume' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'DisplayRenderedImage': <method 'DisplayRenderedImage' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'AbortRender': <method 'AbortRender' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'CreateCanonicalView': <method 'CreateCanonicalView' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetEstimatedRenderTime': <method 'GetEstimatedRenderTime' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'SetFinalColorWindow': <method 'SetFinalColorWindow' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetFinalColorWindow': <method 'GetFinalColorWindow' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'SetFinalColorLevel': <method 'SetFinalColorLevel' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetFinalColorLevel': <method 'GetFinalColorLevel' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'GetFlipMIPComparison': <method 'GetFlipMIPComparison' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, 'ReleaseGraphicsResources': <method 'ReleaseGraphicsResources' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, '__new__': <built-in method __new__ of type object at 0x00007FF8393B3230>, '__repr__': <slot wrapper '__repr__' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, '__str__': <slot wrapper '__str__' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, '__getattribute__': <slot wrapper '__getattribute__' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, '__setattr__': <slot wrapper '__setattr__' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, '__delattr__': <slot wrapper '__delattr__' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, '__dict__': <attribute '__dict__' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, '__this__': <attribute '__this__' of 'vtkmodules.vtkRenderingVolume.vtkFixedPointVolumeRayCastMapper' objects>, '__doc__': 'vtkFixedPointVolumeRayCastMapper - A fixed point mapper for volumes\\n\\nSuperclass: vtkVolumeMapper\\n\\nThis is a software ray caster for rendering volumes in vtkImageData.\\nIt works with all input data types and up to four components. It\\nperforms composite or MIP rendering, and can be intermixed with\\ngeometric data. Space leaping is used to speed up the rendering\\nprocess. In addition, calculation are performed in 15 bit fixed point\\nprecision. This mapper is threaded, and will interleave scan lines\\nacross processors.\\n\\nWARNING: This ray caster may not produce consistent results when the\\nnumber of threads exceeds 1. The class warns if the number of threads\\n> 1. The differences may be subtle. Applications should decide if the\\ntrade-off in performance is worth the lack of consistency.\\n\\nOther limitations of this ray caster include that:\\n- it does not do isosurface ray casting\\n- it does only interpolate before classify compositing\\n- it does only maximum scalar value MIP\\n\\nThis mapper handles all data type from unsigned char through double.\\nHowever, some of the internal calcultions are performed in float and\\ntherefore even the full float range may cause problems for this\\nmapper (both in scalar data values and in spacing between samples).\\n\\nSpace leaping is performed by creating a sub-sampled volume. 4x4x4\\ncells in the original volume are represented by a min, max, and\\ncombined gradient and flag value. The min max volume has three\\nunsigned shorts per 4x4x4 group of cells from the original volume -\\none representing the minimum scalar index (the scalar value adjusted\\nto fit in the 15 bit range), the maximum scalar index, and a third\\nunsigned short which is both the maximum gradient opacity in the\\nneighborhood (an unsigned char) and the flag that is filled in for\\nthe current lookup tables to indicate whether this region can be\\nskipped.\\n\\n@sa\\nvtkVolumeMapper\\n\\n'})"
    __vtkname__ = 'vtkFixedPointVolumeRayCastMapper'