(__text__TEXT"n__literal8__TEXT"%__cstring__TEXT"eb%__data__DATA`(P~__compact_unwind__LDp 8@)__eh_frame__TEXTX h2  [8T P))-.UHAVSH="1HHH=H18IH uHL[A^]DUHAWAVATSH=H5H"1FHL5HHH4HH5D"LHtH u H=H="11HL%H=H1A$8IH uHMtH5!LLIuLH=!1HH=H1A$8IH uHMtH5!LLIuLH=E!1HH=H1A$8IH uHMtH5M!LLIuLH= 1HH=H1A$8IH uHMtH5!LLIuLH= 1HH=H1A$8IH uHMtH5 LLIuLH=H[A\A^A_]fDUHAVSIH5HLt H t3 Ht?HH5K LHH u%HH= HuHtHH5 LHH t3EHt;HH5LHH u!HHEHuſtAHtHH5LHH t8Ht@HH5LHH u&H[A^]HHu[A^]f.UHSH(HuH HE؋FEHEHEH}Ѓu;Hut=H]H=EHt/HHcHu'1H([]ûHuHH([]UHAWAVSH(HuH!HEDvDuHG]ԉ]؅y HHtwL(HEMtKA)AuFHuH}t1}LutNH=^LtfLHt?1CH}1,HE1 ILLPHuHcH([A^A_]ûHuUHAVSH0HuH!HEЋFEHEuGH5~H}HU}t@HHtCHH5{HPE1LEHu+H}Ⱦ1H0[A^]E1HuLUHAVSH HuH HEDvDuHG]]yHHH(HD9u3HPxHt9HHH5HPE1LEHucH}111RE1HuCLHt6HHt)HHH1Q@H߾1HH [A^]UHHHHGzu H=]H5 1]@UHAVSH HuH HEDvDuHG]]y HHt H(HtD9uHHt1H}111 HHHH [A^]f.fUHAWAVSH(HuHV HED~D}HG]ԉ]؅y HHtgLw(Mt^A)AuBHuH}tD}utHA9tAILHu6H}1H([A^A_]ILHuHHUHAVSH HuH0'HEDvDuHG]]y HHt1H(Ht(D9u'H11HuHH1H}111HH [A^]UHAVSH HuHV.HEDvDuHG]]y HHt&H(HtD9uHHt1H}111 HHHH [A^]UHAVSH HuH5HEDvDuHG]]y HHt&H(HtD9uHHt1H}111 HHHH [A^]UHAVSH HuH<HEDvDuHG]]y HHt&H(HtD9uHHt1H}111 HHHH [A^]UHAVSH HuHDHEDvDuHG]]y HHt&H(HtD9uHHt1H}111 HHHH [A^]UHAVSH HuH*KHEDvDuHG]]y HHt#H(HtD9uEt%Ht*11H}111 HHuHcHHH [A^]@UHSHHHHHE^HG)Ѓ*HuHQHEȉ]ЉUԉU؅yHH H_(HHuH}HuH}}EMf.uzf.u{|HH^HuHCQHEȉ]ЉUԉU؅y HHtYH_(HtPHuH}t:EMHHHuHHH5P1H H H;MuHH[]f.UHAWAVSH(HuHXQHED~D}HG]܉]y HHt$Lw(MtD9uEt&IHt.1:H}111)ILIHuLHHH([A^A_]fDUHAWAVSH(HuHRHED~D}HG]ԉ]؅y HHtyLw(MtpA)AuTHuH}tV}utZL1IA9tAILHu6H}1H([A^A_]IL(HuHHf.@UHAVSH HuH0RHEDvDuHG]]y HHtH(HtD9uEt!1Ht+12H}111!H0HcHuHHHH [A^]UHAWAVSH(HuH7RHED~D}HG]܉]y HHt#H(HtD9uAEtHt+12H}111!H8LcHuLHHH([A^A_]f.DUHAVSH HuH2RHEDvDuHG]]y HHt#H(HtD9uEt%Ht*11H}111 H@HuHcHHH [A^]@UHAVSH HuH#RHEDvDuHG]]y HHt+H(Ht"D9u!Et-H(Ht(1.H}111HHHuHHHH [A^]f.DUHAVSH HuHQHEDvDuHG]]y HHt(H(HtD9uEt*H1(Ht(1.H}111HPHuHHHH [A^]fUHSHHHHE^HG)ЃHuHQHEȉ]ЉUԉU؅yHHH_(HH}HuH}HxH}HuH}HuH}HuH}Hup}ExU]em f.uVzT(f.uFzD0f.u6z48f.u&z$@f.uzHf.u (08@HHHHHuHPHE]UUy HHtiH_(Ht`HuH}tJ}tmEMU]emHHXHuQH5O1H H H;MuKHĈ[]1HHHuH`HuHHH H H;MtUHAWAVSH(HuHEPHED~D}HG]܉]y HHt$Lw(MtD9uEt&I Ht.1:H}111)ILhIHuLHHH([A^A_]fDUHAWAVSH(HuHPHED~D}HG]܉]y HHt$Lw(MtD9uEt&IPHt.1:H}111)ILxIHuLHHH([A^A_]fDUHAWAVSH(HuHPHED~D}HG]ԉ]؅y HHt|Lw(MtsA)AuWHuH}tY}ut]L1IA9tAILHu6H}1H([A^A_]ILHuHHf.UHAVSH HuHRHEDvDuHG]]y HHtH(HtD9uEt!1Ht+12H}111!HHcHuHHHH [A^]UHAWAVSH(HuHTHED~D}HG]܉]y HHt#H(HtD9uAEtHt+12H}111!HLcHuLHHH([A^A_]f.DUHAVSH HuHVHEDvDuHG]]y HHt#H(HtD9uEt%Ht*11H}111 HHuHcHHH [A^]@UHAVSH HuHXHEDvDuHG]]y HHt&H(HtD9uH Ht1H}111 HHHH [A^]UHAVSH HuHZHEDvDuHG]]y HHt&H(HtD9uHHt1H}111 HHHH [A^]UHAVSH HuH\HEDvDuHG]]y HHt&H(HtD9uHEHt1H}111 HHHH [A^]UHAVSH HuH#_HEDvDuHG]]y HHt&H(HtD9uHtAHt1H}111 HHHH [A^]UHAVSH HuH:aHEDvDuHG]]y HHt&H(HtD9uHHt1H}111 HHHH [A^]UHAWAVSH(HuHgcHEDvDuHGEԉE؅yHHL(MxeAujH5eH}HU}tcIH5eH}HU}tFILLHHu*HH H}H}1H([A^A_]ÐUHAWAVSH(HuHdcHED~D}HG]ԉ]؅y HHtQLw(MtHA)Au,H5eH}HU}t%}t,Hu9H}1H([A^A_]ILHHHuHHUHSPHH=cHtZH=cHtGH=cHt4H=cHt!H=cHtHH[]H[]f.@UHAWAVSH(HuHHED~D}HG]ԉ]؅y HHt\Lw(MtSA)Au7H5cH}HU}t0}t7LHHu9H}1H([A^A_]ILHHuHHUHAWAVSH(HuHHED~D}HG]ԉ]؅y HHt\Lw(MtSA)Au7H5bH}HU}t0}t7LHHu9H}1H([A^A_]ILHHuHH/A(i)vtkVolumeMapperBlendModesCOMPOSITE_BLENDMAXIMUM_INTENSITY_BLENDMINIMUM_INTENSITY_BLENDAVERAGE_INTENSITY_BLENDADDITIVE_BLENDVTK_CROP_SUBVOLUMEVTK_CROP_FENCEVTK_CROP_INVERTED_FENCEVTK_CROP_CROSSVTK_CROP_INVERTED_CROSSvtkRenderingVolumePython.vtkVolumeMapper.BlendModesvtkRenderingVolumePython.vtkVolumeMappervtkVolumeMapper - Abstract class for a volume mapper Superclass: vtkAbstractVolumeMapper vtkVolumeMapper is the abstract definition of a volume mapper for regular rectilinear data (vtkImageData). Several basic types of volume mappers are supported. IsTypeOfV.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. IsAV.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. SafeDownCastV.SafeDownCast(vtkObjectBase) -> vtkVolumeMapper C++: static vtkVolumeMapper *SafeDownCast(vtkObjectBase *o) NewInstanceV.NewInstance() -> vtkVolumeMapper C++: vtkVolumeMapper *NewInstance() SetInputDataV.SetInputData(vtkImageData) C++: virtual void SetInputData(vtkImageData *) V.SetInputData(vtkDataSet) C++: virtual void SetInputData(vtkDataSet *) Set/Get the input data GetInputV.GetInput() -> vtkImageData C++: vtkImageData *GetInput() Set/Get the input data SetBlendModeV.SetBlendMode(int) C++: virtual void SetBlendMode(int _arg) Set/Get the blend mode. The default mode is Composite where the scalar values are sampled through the volume and composited in a front-to-back scheme through alpha blending. The final color and opacity is determined using the color and opacity transfer functions. Maximum and minimum intensity blend modes use the maximum and minimum scalar values, respectively, along the sampling ray. The final color and opacity is determined by passing the resultant value through the color and opacity transfer functions. Additive blend mode accumulates scalar values by passing each value through the opacity transfer function and then adding up the product of the value and its opacity. In other words, the scalar values are scaled using the opacity transfer function and summed to derive the final color. Note that the resulting image is always grayscale i.e. aggregated values are not passed through the color transfer function. This is because the final value is a derived value and not a real data value along the sampling ray. Average intensity blend mode works similar to the additive blend mode where the scalar values are multiplied by opacity calculated from the opacity transfer function and then added. The additional step here is to divide the sum by the number of samples taken through the volume. One can control the scalar range by setting the AverageIPScalarRange ivar to disregard scalar values, not in the range of interest, from the average computation. As is the case with the additive intensity projection, the final image will always be grayscale i.e. the aggregated values are not passed through the color transfer function. This is because the resultant value is a derived value and not a real data value along the sampling ray. ote vtkVolumeMapper::AVERAGE_INTENSITY_BLEND is only supported by the vtkGPUVolumeRayCastMapper with the OpenGL2 backend. \sa SetAverageIPScalarRange() SetBlendModeToCompositeV.SetBlendModeToComposite() C++: void SetBlendModeToComposite() Set/Get the blend mode. The default mode is Composite where the scalar values are sampled through the volume and composited in a front-to-back scheme through alpha blending. The final color and opacity is determined using the color and opacity transfer functions. Maximum and minimum intensity blend modes use the maximum and minimum scalar values, respectively, along the sampling ray. The final color and opacity is determined by passing the resultant value through the color and opacity transfer functions. Additive blend mode accumulates scalar values by passing each value through the opacity transfer function and then adding up the product of the value and its opacity. In other words, the scalar values are scaled using the opacity transfer function and summed to derive the final color. Note that the resulting image is always grayscale i.e. aggregated values are not passed through the color transfer function. This is because the final value is a derived value and not a real data value along the sampling ray. Average intensity blend mode works similar to the additive blend mode where the scalar values are multiplied by opacity calculated from the opacity transfer function and then added. The additional step here is to divide the sum by the number of samples taken through the volume. One can control the scalar range by setting the AverageIPScalarRange ivar to disregard scalar values, not in the range of interest, from the average computation. As is the case with the additive intensity projection, the final image will always be grayscale i.e. the aggregated values are not passed through the color transfer function. This is because the resultant value is a derived value and not a real data value along the sampling ray. ote vtkVolumeMapper::AVERAGE_INTENSITY_BLEND is only supported by the vtkGPUVolumeRayCastMapper with the OpenGL2 backend. \sa SetAverageIPScalarRange() SetBlendModeToMaximumIntensityV.SetBlendModeToMaximumIntensity() C++: void SetBlendModeToMaximumIntensity() Set/Get the blend mode. The default mode is Composite where the scalar values are sampled through the volume and composited in a front-to-back scheme through alpha blending. The final color and opacity is determined using the color and opacity transfer functions. Maximum and minimum intensity blend modes use the maximum and minimum scalar values, respectively, along the sampling ray. The final color and opacity is determined by passing the resultant value through the color and opacity transfer functions. Additive blend mode accumulates scalar values by passing each value through the opacity transfer function and then adding up the product of the value and its opacity. In other words, the scalar values are scaled using the opacity transfer function and summed to derive the final color. Note that the resulting image is always grayscale i.e. aggregated values are not passed through the color transfer function. This is because the final value is a derived value and not a real data value along the sampling ray. Average intensity blend mode works similar to the additive blend mode where the scalar values are multiplied by opacity calculated from the opacity transfer function and then added. The additional step here is to divide the sum by the number of samples taken through the volume. One can control the scalar range by setting the AverageIPScalarRange ivar to disregard scalar values, not in the range of interest, from the average computation. As is the case with the additive intensity projection, the final image will always be grayscale i.e. the aggregated values are not passed through the color transfer function. This is because the resultant value is a derived value and not a real data value along the sampling ray. ote vtkVolumeMapper::AVERAGE_INTENSITY_BLEND is only supported by the vtkGPUVolumeRayCastMapper with the OpenGL2 backend. \sa SetAverageIPScalarRange() SetBlendModeToMinimumIntensityV.SetBlendModeToMinimumIntensity() C++: void SetBlendModeToMinimumIntensity() Set/Get the blend mode. The default mode is Composite where the scalar values are sampled through the volume and composited in a front-to-back scheme through alpha blending. The final color and opacity is determined using the color and opacity transfer functions. Maximum and minimum intensity blend modes use the maximum and minimum scalar values, respectively, along the sampling ray. The final color and opacity is determined by passing the resultant value through the color and opacity transfer functions. Additive blend mode accumulates scalar values by passing each value through the opacity transfer function and then adding up the product of the value and its opacity. In other words, the scalar values are scaled using the opacity transfer function and summed to derive the final color. Note that the resulting image is always grayscale i.e. aggregated values are not passed through the color transfer function. This is because the final value is a derived value and not a real data value along the sampling ray. Average intensity blend mode works similar to the additive blend mode where the scalar values are multiplied by opacity calculated from the opacity transfer function and then added. The additional step here is to divide the sum by the number of samples taken through the volume. One can control the scalar range by setting the AverageIPScalarRange ivar to disregard scalar values, not in the range of interest, from the average computation. As is the case with the additive intensity projection, the final image will always be grayscale i.e. the aggregated values are not passed through the color transfer function. This is because the resultant value is a derived value and not a real data value along the sampling ray. ote vtkVolumeMapper::AVERAGE_INTENSITY_BLEND is only supported by the vtkGPUVolumeRayCastMapper with the OpenGL2 backend. \sa SetAverageIPScalarRange() SetBlendModeToAverageIntensityV.SetBlendModeToAverageIntensity() C++: void SetBlendModeToAverageIntensity() Set/Get the blend mode. The default mode is Composite where the scalar values are sampled through the volume and composited in a front-to-back scheme through alpha blending. The final color and opacity is determined using the color and opacity transfer functions. Maximum and minimum intensity blend modes use the maximum and minimum scalar values, respectively, along the sampling ray. The final color and opacity is determined by passing the resultant value through the color and opacity transfer functions. Additive blend mode accumulates scalar values by passing each value through the opacity transfer function and then adding up the product of the value and its opacity. In other words, the scalar values are scaled using the opacity transfer function and summed to derive the final color. Note that the resulting image is always grayscale i.e. aggregated values are not passed through the color transfer function. This is because the final value is a derived value and not a real data value along the sampling ray. Average intensity blend mode works similar to the additive blend mode where the scalar values are multiplied by opacity calculated from the opacity transfer function and then added. The additional step here is to divide the sum by the number of samples taken through the volume. One can control the scalar range by setting the AverageIPScalarRange ivar to disregard scalar values, not in the range of interest, from the average computation. As is the case with the additive intensity projection, the final image will always be grayscale i.e. the aggregated values are not passed through the color transfer function. This is because the resultant value is a derived value and not a real data value along the sampling ray. ote vtkVolumeMapper::AVERAGE_INTENSITY_BLEND is only supported by the vtkGPUVolumeRayCastMapper with the OpenGL2 backend. \sa SetAverageIPScalarRange() SetBlendModeToAdditiveV.SetBlendModeToAdditive() C++: void SetBlendModeToAdditive() Set/Get the blend mode. The default mode is Composite where the scalar values are sampled through the volume and composited in a front-to-back scheme through alpha blending. The final color and opacity is determined using the color and opacity transfer functions. Maximum and minimum intensity blend modes use the maximum and minimum scalar values, respectively, along the sampling ray. The final color and opacity is determined by passing the resultant value through the color and opacity transfer functions. Additive blend mode accumulates scalar values by passing each value through the opacity transfer function and then adding up the product of the value and its opacity. In other words, the scalar values are scaled using the opacity transfer function and summed to derive the final color. Note that the resulting image is always grayscale i.e. aggregated values are not passed through the color transfer function. This is because the final value is a derived value and not a real data value along the sampling ray. Average intensity blend mode works similar to the additive blend mode where the scalar values are multiplied by opacity calculated from the opacity transfer function and then added. The additional step here is to divide the sum by the number of samples taken through the volume. One can control the scalar range by setting the AverageIPScalarRange ivar to disregard scalar values, not in the range of interest, from the average computation. As is the case with the additive intensity projection, the final image will always be grayscale i.e. the aggregated values are not passed through the color transfer function. This is because the resultant value is a derived value and not a real data value along the sampling ray. ote vtkVolumeMapper::AVERAGE_INTENSITY_BLEND is only supported by the vtkGPUVolumeRayCastMapper with the OpenGL2 backend. \sa SetAverageIPScalarRange() GetBlendModeV.GetBlendMode() -> int C++: virtual int GetBlendMode() Set/Get the blend mode. The default mode is Composite where the scalar values are sampled through the volume and composited in a front-to-back scheme through alpha blending. The final color and opacity is determined using the color and opacity transfer functions. Maximum and minimum intensity blend modes use the maximum and minimum scalar values, respectively, along the sampling ray. The final color and opacity is determined by passing the resultant value through the color and opacity transfer functions. Additive blend mode accumulates scalar values by passing each value through the opacity transfer function and then adding up the product of the value and its opacity. In other words, the scalar values are scaled using the opacity transfer function and summed to derive the final color. Note that the resulting image is always grayscale i.e. aggregated values are not passed through the color transfer function. This is because the final value is a derived value and not a real data value along the sampling ray. Average intensity blend mode works similar to the additive blend mode where the scalar values are multiplied by opacity calculated from the opacity transfer function and then added. The additional step here is to divide the sum by the number of samples taken through the volume. One can control the scalar range by setting the AverageIPScalarRange ivar to disregard scalar values, not in the range of interest, from the average computation. As is the case with the additive intensity projection, the final image will always be grayscale i.e. the aggregated values are not passed through the color transfer function. This is because the resultant value is a derived value and not a real data value along the sampling ray. ote vtkVolumeMapper::AVERAGE_INTENSITY_BLEND is only supported by the vtkGPUVolumeRayCastMapper with the OpenGL2 backend. \sa SetAverageIPScalarRange() SetAverageIPScalarRangeV.SetAverageIPScalarRange(float, float) C++: void SetAverageIPScalarRange(double, double) V.SetAverageIPScalarRange((float, float)) C++: void SetAverageIPScalarRange(double a[2]) GetAverageIPScalarRangeV.GetAverageIPScalarRange() -> (float, float) C++: double *GetAverageIPScalarRange() Set/Get the scalar range to be considered for average intensity projection blend mode. Only scalar values between this range will be averaged during ray casting. This can be useful when volume rendering CT datasets where the areas occupied by air would deviate the final rendering. By default, the range is set to (VTK_DOUBLE_MIN, VTK_DOUBLE_MAX). \sa SetBlendModeToAverageIntensity() SetCroppingV.SetCropping(int) C++: virtual void SetCropping(int _arg) Turn On/Off orthogonal cropping. (Clipping planes are perpendicular to the coordinate axes.) GetCroppingMinValueV.GetCroppingMinValue() -> int C++: virtual int GetCroppingMinValue() Turn On/Off orthogonal cropping. (Clipping planes are perpendicular to the coordinate axes.) GetCroppingMaxValueV.GetCroppingMaxValue() -> int C++: virtual int GetCroppingMaxValue() Turn On/Off orthogonal cropping. (Clipping planes are perpendicular to the coordinate axes.) GetCroppingV.GetCropping() -> int C++: virtual int GetCropping() Turn On/Off orthogonal cropping. (Clipping planes are perpendicular to the coordinate axes.) CroppingOnV.CroppingOn() C++: virtual void CroppingOn() Turn On/Off orthogonal cropping. (Clipping planes are perpendicular to the coordinate axes.) CroppingOffV.CroppingOff() C++: virtual void CroppingOff() Turn On/Off orthogonal cropping. (Clipping planes are perpendicular to the coordinate axes.) SetCroppingRegionPlanesV.SetCroppingRegionPlanes(float, float, float, float, float, float) C++: void SetCroppingRegionPlanes(double, double, double, double, double, double) V.SetCroppingRegionPlanes((float, float, float, float, float, float)) C++: void SetCroppingRegionPlanes(double a[6]) GetCroppingRegionPlanesV.GetCroppingRegionPlanes() -> (float, float, float, float, float, float) C++: double *GetCroppingRegionPlanes() Set/Get the Cropping Region Planes ( xmin, xmax, ymin, ymax, zmin, zmax ) These planes are defined in volume coordinates - spacing and origin are considered. GetVoxelCroppingRegionPlanesV.GetVoxelCroppingRegionPlanes() -> (float, float, float, float, float, float) C++: double *GetVoxelCroppingRegionPlanes() Get the cropping region planes in voxels. Only valid during the rendering process SetCroppingRegionFlagsV.SetCroppingRegionFlags(int) C++: virtual void SetCroppingRegionFlags(int _arg) Set the flags for the cropping regions. The clipping planes divide the volume into 27 regions - there is one bit for each region. The regions start from the one containing voxel (0,0,0), moving along the x axis fastest, the y axis next, and the z axis slowest. These are represented from the lowest bit to bit number 27 in the integer containing the flags. There are several convenience functions to set some common configurations - subvolume (the default), fence (between any of the clip plane pairs), inverted fence, cross (between any two of the clip plane pairs) and inverted cross. GetCroppingRegionFlagsMinValueV.GetCroppingRegionFlagsMinValue() -> int C++: virtual int GetCroppingRegionFlagsMinValue() Set the flags for the cropping regions. The clipping planes divide the volume into 27 regions - there is one bit for each region. The regions start from the one containing voxel (0,0,0), moving along the x axis fastest, the y axis next, and the z axis slowest. These are represented from the lowest bit to bit number 27 in the integer containing the flags. There are several convenience functions to set some common configurations - subvolume (the default), fence (between any of the clip plane pairs), inverted fence, cross (between any two of the clip plane pairs) and inverted cross. GetCroppingRegionFlagsMaxValueV.GetCroppingRegionFlagsMaxValue() -> int C++: virtual int GetCroppingRegionFlagsMaxValue() Set the flags for the cropping regions. The clipping planes divide the volume into 27 regions - there is one bit for each region. The regions start from the one containing voxel (0,0,0), moving along the x axis fastest, the y axis next, and the z axis slowest. These are represented from the lowest bit to bit number 27 in the integer containing the flags. There are several convenience functions to set some common configurations - subvolume (the default), fence (between any of the clip plane pairs), inverted fence, cross (between any two of the clip plane pairs) and inverted cross. GetCroppingRegionFlagsV.GetCroppingRegionFlags() -> int C++: virtual int GetCroppingRegionFlags() Set the flags for the cropping regions. The clipping planes divide the volume into 27 regions - there is one bit for each region. The regions start from the one containing voxel (0,0,0), moving along the x axis fastest, the y axis next, and the z axis slowest. These are represented from the lowest bit to bit number 27 in the integer containing the flags. There are several convenience functions to set some common configurations - subvolume (the default), fence (between any of the clip plane pairs), inverted fence, cross (between any two of the clip plane pairs) and inverted cross. SetCroppingRegionFlagsToSubVolumeV.SetCroppingRegionFlagsToSubVolume() C++: void SetCroppingRegionFlagsToSubVolume() Set the flags for the cropping regions. The clipping planes divide the volume into 27 regions - there is one bit for each region. The regions start from the one containing voxel (0,0,0), moving along the x axis fastest, the y axis next, and the z axis slowest. These are represented from the lowest bit to bit number 27 in the integer containing the flags. There are several convenience functions to set some common configurations - subvolume (the default), fence (between any of the clip plane pairs), inverted fence, cross (between any two of the clip plane pairs) and inverted cross. SetCroppingRegionFlagsToFenceV.SetCroppingRegionFlagsToFence() C++: void SetCroppingRegionFlagsToFence() Set the flags for the cropping regions. The clipping planes divide the volume into 27 regions - there is one bit for each region. The regions start from the one containing voxel (0,0,0), moving along the x axis fastest, the y axis next, and the z axis slowest. These are represented from the lowest bit to bit number 27 in the integer containing the flags. There are several convenience functions to set some common configurations - subvolume (the default), fence (between any of the clip plane pairs), inverted fence, cross (between any two of the clip plane pairs) and inverted cross. SetCroppingRegionFlagsToInvertedFenceV.SetCroppingRegionFlagsToInvertedFence() C++: void SetCroppingRegionFlagsToInvertedFence() Set the flags for the cropping regions. The clipping planes divide the volume into 27 regions - there is one bit for each region. The regions start from the one containing voxel (0,0,0), moving along the x axis fastest, the y axis next, and the z axis slowest. These are represented from the lowest bit to bit number 27 in the integer containing the flags. There are several convenience functions to set some common configurations - subvolume (the default), fence (between any of the clip plane pairs), inverted fence, cross (between any two of the clip plane pairs) and inverted cross. SetCroppingRegionFlagsToCrossV.SetCroppingRegionFlagsToCross() C++: void SetCroppingRegionFlagsToCross() Set the flags for the cropping regions. The clipping planes divide the volume into 27 regions - there is one bit for each region. The regions start from the one containing voxel (0,0,0), moving along the x axis fastest, the y axis next, and the z axis slowest. These are represented from the lowest bit to bit number 27 in the integer containing the flags. There are several convenience functions to set some common configurations - subvolume (the default), fence (between any of the clip plane pairs), inverted fence, cross (between any two of the clip plane pairs) and inverted cross. SetCroppingRegionFlagsToInvertedCrossV.SetCroppingRegionFlagsToInvertedCross() C++: void SetCroppingRegionFlagsToInvertedCross() Set the flags for the cropping regions. The clipping planes divide the volume into 27 regions - there is one bit for each region. The regions start from the one containing voxel (0,0,0), moving along the x axis fastest, the y axis next, and the z axis slowest. These are represented from the lowest bit to bit number 27 in the integer containing the flags. There are several convenience functions to set some common configurations - subvolume (the default), fence (between any of the clip plane pairs), inverted fence, cross (between any two of the clip plane pairs) and inverted cross. RenderV.Render(vtkRenderer, vtkVolume) C++: void Render(vtkRenderer *ren, vtkVolume *vol) override = 0; WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE DO NOT USE THIS METHOD OUTSIDE OF THE RENDERING PROCESS Render the volume ReleaseGraphicsResourcesV.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. vtkAbstractVolumeMappervtkAbstractMapper3DvtkAbstractMappervtkAlgorithmvtkObjectvtkObjectBase@V *vtkImageData@V *vtkDataSetvtkImageDatavtkDataSetvtkRenderervtkVolumevtkWindow#  $HD4$3%<%=&A&6'C'''(((()+)0088w@@RHqH-PDPWW__p```blbccccxdde$eeeLfdf}gghhiiPlolo7oqqttSwqw z0z||_fLeK!P s!` a !!<!a !0 ! !p ! ! !` aa!pa0!!!P aaa!Pa!!`!!!@!aa 0!a"azRx $PmKAC C,DxmAC G$tosAC C$0qAC E$q AC I$rAC G$(sAC G$<t<AC $dtAC G$tAC I$HuAC G$uAC G$8vAC G$,vAC G$T(wAC G$|wAC G$(xAC E$yAC I$8zAC I${AC G$D{AC I$l0|AC G$|AC G$P}AC G$}AC H$ AC I$4AC I$\AC I$AC G$AC I$AC G$0AC G$$AC G$L AC G$tAC G$AC G$AC I$PAC I$AC B$<`AC I$dAC I"F=".-"J-".-"T-|"L-o"N"M-$"!F=!.-!J-!.-!U-!L-!n!M-D!!G-!Z-  Z-  Z-  Z-  Z-  F= .-g J-M .-< L-/  M-J-K-F=.-rL-eUL-HM-F=J-.-|M-R&F=J-.-M-F=}J-e.-<M-F=J-.-M-rFF==J-%.-M-0-.-J-r.-LM-"0-.-J-.-M-d60-).-J-.-M-F=.-bJ-H.-Q-M-H-s.-]J-E.-M-H-.-J-.-^M-4X- Y=F=.-Y=I-.-kN-HM-2.-AP-,P-P-P-P-P-M-_Y=;F=/.-J-.-M-~F=r.-bJ-J.-M-0-.-J-.-lM-B 0-.-J-.-M-V0-I.-6J-.-M-F=.-J-e.-%Q-M-H-.-}J-e.->M-X-Y=I-F=.-N-rM-\ P- P- M- l Y=I 0-< .-* J- .- M-  F= J-u .-L M-"  F= J- .- M- V F=M J-5 .- M-  F= J- .-l M-B  J- F= .- M-  F={ .-] J-C .- Q-M-S-J-o.-gV-LM-"I-W-@-<-:-S-v.-lJ-V.-B M-S-.-J-.-u]L-P2.-0-.-J-.-,-Z-}O-NM-$0-.-J-.-,-Z-O-pE/-@8E-0E---/---0-0-E-E---0---uf0-W0-ME-H?E-2--'0- --*-6-E---E-yoC-c\E-O--D8E-C-E---E-C-E---|E-_UC-IBE-5--*E-1=C-E---R-6-D-ys8-le^?E-$1=C- ('x&phX%PH8$0(#"! xphXPH80(xphXPH80(xphX PH8 0(   xphXPH803>=PBH8905(4 A?;7@217`@ `@ `@ `@ `@ `G `   b  gt z  0 V p I   ` 8  B  p 0]  <Px   P  ` :|@2 0! "3PJ [% 9&k7a0O=)uRv={j`H _PyType_Ready_PyvtkAbstractVolumeMapper_ClassNew_PyvtkVolumeMapper_ClassNew_PyVTKObject_New__ZN15vtkVolumeMapper8GetInputEv__ZN13vtkPythonArgs16PureVirtualErrorEv_PyVTKObject_GetSet__ZN15vtkVolumeMapper12SetInputDataEP10vtkDataSet__Py_NoneStruct__ZN13vtkPythonUtil12AddEnumToMapEP11_typeobject_PyVTKObject_GetObject__ZL25PyvtkVolumeMapper_Methods__ZL38PyvtkVolumeMapper_SetInputData_Methods_PyObject_GenericSetAttr_PyObject_GenericGetAttr_PyVTKObject_Repr_PyVTKAddFile_vtkVolumeMapper_PyVTKObject_AsBuffer_strcmp___stack_chk_fail_PyObject_GC_Del_PyVTKObject_Check__Z37PyvtkVolumeMapper_BlendModes_FromEnumi__ZN13vtkPythonArgs13ArgCountErrorEii__ZN13vtkPythonArgs8GetArrayEPdi__ZN13vtkPythonArgs10BuildTupleEPKdi__ZN13vtkPythonArgs8GetValueERi_PyLong_FromLong_PyDict_SetItemString_PyVTKObject_String_PyVTKObject_SetFlag_Py_BuildValue_PyVTKObject_Delete_PyVTKObject_Traverse__ZN13vtkPythonUtil20GetObjectFromPointerEP13vtkObjectBase__ZL33PyvtkVolumeMapper_BlendModes_Type__ZL22PyvtkVolumeMapper_Type_PyLong_Type_PyType_Type_PyFloat_FromDouble_PyObject_Free___stack_chk_guard_PyErr_Occurred_PyVTKClass_Add__ZN13vtkPythonArgs8GetValueERd__Py_Dealloc__ZN13vtkPythonArgs8GetValueERPc__ZN13vtkPythonArgs13ArgCountErrorEiPKc__ZN23vtkAbstractVolumeMapper8IsTypeOfEPKc__ZN13vtkObjectBase8IsTypeOfEPKc__ZN13vtkPythonArgs17GetArgAsVTKObjectEPKcRb__ZN15vtkVolumeMapper12SetInputDataEP12vtkImageData__ZN17vtkPythonOverload10CallMethodEP11PyMethodDefP7_objectS3___ZN13vtkPythonArgs19GetSelfFromFirstArgEP7_objectS1___ZL48PyvtkVolumeMapper_SetBlendModeToMaximumIntensityP7_objectS0___ZL48PyvtkVolumeMapper_SetBlendModeToMinimumIntensityP7_objectS0___ZL48PyvtkVolumeMapper_SetBlendModeToAverageIntensityP7_objectS0___ZL26PyvtkVolumeMapper_GetInputP7_objectS0___ZL30PyvtkVolumeMapper_SafeDownCastP7_objectS0___ZL47PyvtkVolumeMapper_SetCroppingRegionFlagsToCrossP7_objectS0___ZL55PyvtkVolumeMapper_SetCroppingRegionFlagsToInvertedCrossP7_objectS0___ZL40PyvtkVolumeMapper_SetCroppingRegionFlagsP7_objectS0___ZL40PyvtkVolumeMapper_GetCroppingRegionFlagsP7_objectS0___ZL41PyvtkVolumeMapper_SetCroppingRegionPlanesP7_objectS0___ZL41PyvtkVolumeMapper_GetCroppingRegionPlanesP7_objectS0___ZL46PyvtkVolumeMapper_GetVoxelCroppingRegionPlanesP7_objectS0___ZL42PyvtkVolumeMapper_ReleaseGraphicsResourcesP7_objectS0___ZL24PyvtkVolumeMapper_RenderP7_objectS0___ZL28PyvtkVolumeMapper_CroppingOnP7_objectS0___ZL29PyvtkVolumeMapper_SetCroppingP7_objectS0___ZL29PyvtkVolumeMapper_GetCroppingP7_objectS0___ZL29PyvtkVolumeMapper_CroppingOffP7_objectS0___ZL26PyvtkVolumeMapper_IsTypeOfP7_objectS0___ZL40PyvtkVolumeMapper_SetBlendModeToAdditiveP7_objectS0___ZL48PyvtkVolumeMapper_GetCroppingRegionFlagsMaxValueP7_objectS0___ZL37PyvtkVolumeMapper_GetCroppingMaxValueP7_objectS0___ZL48PyvtkVolumeMapper_GetCroppingRegionFlagsMinValueP7_objectS0___ZL37PyvtkVolumeMapper_GetCroppingMinValueP7_objectS0___ZL41PyvtkVolumeMapper_SetBlendModeToCompositeP7_objectS0___ZL51PyvtkVolumeMapper_SetCroppingRegionFlagsToSubVolumeP7_objectS0___ZL41PyvtkVolumeMapper_SetAverageIPScalarRangeP7_objectS0___ZL41PyvtkVolumeMapper_GetAverageIPScalarRangeP7_objectS0___ZL30PyvtkVolumeMapper_SetBlendModeP7_objectS0___ZL30PyvtkVolumeMapper_GetBlendModeP7_objectS0___ZL47PyvtkVolumeMapper_SetCroppingRegionFlagsToFenceP7_objectS0___ZL55PyvtkVolumeMapper_SetCroppingRegionFlagsToInvertedFenceP7_objectS0___ZL29PyvtkVolumeMapper_NewInstanceP7_objectS0___ZL30PyvtkVolumeMapper_SetInputDataP7_objectS0___ZL21PyvtkVolumeMapper_IsAP7_objectS0___ZL33PyvtkVolumeMapper_SetInputData_s2P7_objectS0___ZL33PyvtkVolumeMapper_SetInputData_s1P7_objectS0_