vispy 0.9.5__cp38-cp38-win_amd64.whl → 0.14.0__cp38-cp38-win_amd64.whl

vispy/visuals/volume.py

@@ -34,14 +34,18 @@ The ray is expressed in coordinates local to the volume (i.e. texture
 coordinates).
 
 """
+from __future__ import annotations
+
+from typing import Optional
 from functools import lru_cache
+import warnings
 
-from ._scalable_textures import CPUScaledTexture3D, GPUScaledTextured3D
+from ._scalable_textures import CPUScaledTexture3D, GPUScaledTextured3D, Texture2D
 from ..gloo import VertexBuffer, IndexBuffer
-from ..gloo.texture import should_cast_to_f32
 from . import Visual
 from .shaders import Function
 from ..color import get_colormap
+from ..io import load_spatial_filters
 
 import numpy as np
 
@@ -86,6 +90,8 @@ uniform float gamma;
 uniform float u_threshold;
 uniform float u_attenuation;
 uniform float u_relative_step_size;
+uniform float u_mip_cutoff;
+uniform float u_minip_cutoff;
 
 //varyings
 varying vec3 v_position;
@@ -139,16 +145,16 @@ vec4 calculateColor(vec4 betterColor, vec3 loc, vec3 step)
 
     // calculate normal vector from gradient
     vec3 N; // normal
-    color1 = $sample( u_volumetex, loc+vec3(-step[0],0.0,0.0) );
-    color2 = $sample( u_volumetex, loc+vec3(step[0],0.0,0.0) );
+    color1 = $get_data(loc+vec3(-step[0],0.0,0.0) );
+    color2 = $get_data(loc+vec3(step[0],0.0,0.0) );
     N[0] = colorToVal(color1) - colorToVal(color2);
     betterColor = max(max(color1, color2),betterColor);
-    color1 = $sample( u_volumetex, loc+vec3(0.0,-step[1],0.0) );
-    color2 = $sample( u_volumetex, loc+vec3(0.0,step[1],0.0) );
+    color1 = $get_data(loc+vec3(0.0,-step[1],0.0) );
+    color2 = $get_data(loc+vec3(0.0,step[1],0.0) );
     N[1] = colorToVal(color1) - colorToVal(color2);
     betterColor = max(max(color1, color2),betterColor);
-    color1 = $sample( u_volumetex, loc+vec3(0.0,0.0,-step[2]) );
-    color2 = $sample( u_volumetex, loc+vec3(0.0,0.0,step[2]) );
+    color1 = $get_data(loc+vec3(0.0,0.0,-step[2]) );
+    color2 = $get_data(loc+vec3(0.0,0.0,step[2]) );
     N[2] = colorToVal(color1) - colorToVal(color2);
     betterColor = max(max(color1, color2),betterColor);
     float gm = length(N); // gradient magnitude
@@ -229,12 +235,10 @@ void main() {
     // fragment.
     view_ray = normalize(farpos.xyz - nearpos.xyz);
 
-    // Keep track of wheter a surface was found (used for depth)
-    // Need to do it before raycasting setup because the "plane" mode needs to set
-    // the depth during that phase.
-    vec3 surface_point;
-    bool surface_found = false;
-    
+    // Variables to keep track of where to set the frag depth.
+    // frag_depth_point is in data coordinates.
+    vec3 frag_depth_point;
+
     // Set up the ray casting
     // This snippet must define three variables:
     // vec3 start_loc - the starting location of the ray in texture coordinates
@@ -255,8 +259,9 @@ void main() {
     vec3 loc = start_loc;
     int iter = 0;
 
-    // Keep track of whether texture has been sampled
-    int texture_sampled = 0;
+    // keep track if the texture is ever sampled; if not, fragment will be discarded
+    // this allows us to discard fragments that only traverse clipped parts of the texture
+    bool texture_sampled = false;
 
     while (iter < nsteps) {
         for (iter=iter; iter<nsteps; iter++)
@@ -266,9 +271,9 @@ void main() {
             if (distance_from_clip >= 0)
             {
                 // Get sample color
-                vec4 color = $sample(u_volumetex, loc);
+                vec4 color = $get_data(loc);
                 float val = color.r;
-                texture_sampled = 1;
+                texture_sampled = true;
 
                 $in_loop
             }
@@ -276,28 +281,18 @@ void main() {
             loc += step;
         }
     }
-    
-    // discard fragment if texture not sampled
-    if ( texture_sampled != 1 ) {
+
+    if (!texture_sampled)
         discard;
-    }
-    
-    $after_loop
 
-    if (surface_found == true) {
-        // if a surface was found, use it to set the depth buffer
-        vec4 position2 = vec4(surface_point, 1);
-        vec4 iproj = $viewtransformf(position2);
-        iproj.z /= iproj.w;
-        gl_FragDepth = (iproj.z+1.0)/2.0;
-    }
-    else {
-        gl_FragDepth = gl_FragCoord.z;
-    }
+    $after_loop
 
+    // set frag depth
+    vec4 frag_depth_vector = vec4(frag_depth_point, 1);
+    vec4 iproj = $viewtransformf(frag_depth_vector);
+    iproj.z /= iproj.w;
+    gl_FragDepth = (iproj.z+1.0)/2.0;
 }
-
-
 """  # noqa
 
 _RAYCASTING_SETUP_VOLUME = """
@@ -323,6 +318,9 @@ _RAYCASTING_SETUP_VOLUME = """
     vec3 step = ((v_position - front) / u_shape) / f_nsteps;
     // 0.5 offset needed to get back to correct texture coordinates (vispy#2239)
     vec3 start_loc = (front + 0.5) / u_shape;
+
+    // set frag depth to the cube face; this can be overridden by projection snippets
+    frag_depth_point = front;
 """
 
 _RAYCASTING_SETUP_PLANE = """
@@ -344,9 +342,8 @@ _RAYCASTING_SETUP_PLANE = """
     out_of_bounds += float(intersection_tex.z > 1);
     out_of_bounds += float(intersection_tex.z < 0);
 
-    if (out_of_bounds > 0) {
+    if (out_of_bounds > 0)
         discard;
-    }
 
 
     // Decide how many steps to take
@@ -361,78 +358,125 @@ _RAYCASTING_SETUP_PLANE = """
     vec3 step = N / u_shape;
     vec3 start_loc = intersection_tex - ((step * f_nsteps) / 2);
 
-    // Set depth value
-    surface_point = intersection;
-    surface_found = true;
+    // Ensure that frag depth value will be set to plane intersection
+    frag_depth_point = intersection;
 """
 
 
 _MIP_SNIPPETS = dict(
     before_loop="""
-        float maxval = -99999.0; // The maximum encountered value
+        float maxval = u_mip_cutoff; // The maximum encountered value
         int maxi = -1;  // Where the maximum value was encountered
         """,
     in_loop="""
-        if( val > maxval ) {
+        if ( val > maxval ) {
             maxval = val;
             maxi = iter;
+            if ( maxval >= clim.y ) {
+                // stop if no chance of finding a higher maxval
+                iter = nsteps;
+            }
         }
         """,
     after_loop="""
         // Refine search for max value, but only if anything was found
         if ( maxi > -1 ) {
-            loc = start_loc + step * (float(maxi) - 0.5);
+            // Calculate starting location of ray for sampling
+            vec3 start_loc_refine = start_loc + step * (float(maxi) - 0.5);
+            loc = start_loc_refine;
+
+            // Variables to keep track of current value and where max was encountered
+            vec3 max_loc_tex = start_loc_refine;
+
+            vec3 small_step = step * 0.1;
             for (int i=0; i<10; i++) {
-                maxval = max(maxval, $sample(u_volumetex, loc).r);
-                loc += step * 0.1;
+                float val = $get_data(loc).r;
+                if ( val > maxval) {
+                    maxval = val;
+                    max_loc_tex = start_loc_refine + (small_step * i);
+                }
+                loc += small_step;
             }
+            frag_depth_point = max_loc_tex * u_shape;
             gl_FragColor = applyColormap(maxval);
+        } else {
+            discard;
         }
         """,
 )
 
 _ATTENUATED_MIP_SNIPPETS = dict(
     before_loop="""
-        float maxval = -99999.0; // The maximum encountered value
+        float maxval = u_mip_cutoff; // The maximum encountered value
         float sumval = 0.0; // The sum of the encountered values
-        float scaled = 0.0; // The scaled value
-        int maxi = 0;  // Where the maximum value was encountered
-        vec3 maxloc = vec3(0.0);  // Location where the maximum value was encountered
+        float scale = 0.0; // The cumulative attenuation
+        int maxi = -1;  // Where the maximum value was encountered
+        vec3 max_loc_tex = vec3(0.0);  // Location where the maximum value was encountered
         """,
     in_loop="""
-        sumval = sumval + val;
-        scaled = val * exp(-u_attenuation * (sumval - 1) / u_relative_step_size);
-        if( scaled > maxval ) {
-            maxval = scaled;
+        // Scale and clamp accumulation in `sumval` by contrast limits so that:
+        // * attenuation value does not depend on data values
+        // * negative values do not amplify instead of attenuate
+        sumval = sumval + clamp((val - clim.x) / (clim.y - clim.x), 0.0, 1.0);
+        scale = exp(-u_attenuation * (sumval - 1) / u_relative_step_size);
+        if( maxval > scale * clim.y ) {
+            // stop if no chance of finding a higher maxval
+            iter = nsteps;
+        } else if( val * scale > maxval ) {
+            maxval = val * scale;
             maxi = iter;
-            maxloc = loc;
+            max_loc_tex = loc;
         }
         """,
     after_loop="""
-        gl_FragColor = applyColormap(maxval);
+        if ( maxi > -1 ) {
+            frag_depth_point = max_loc_tex * u_shape;
+            gl_FragColor = applyColormap(maxval);
+        }
+        else {
+            discard;
+        }
         """,
 )
 
 _MINIP_SNIPPETS = dict(
     before_loop="""
-        float minval = 99999.0; // The minimum encountered value
+        float minval = u_minip_cutoff; // The minimum encountered value
         int mini = -1;  // Where the minimum value was encountered
         """,
     in_loop="""
-        if( val < minval ) {
+        if ( val < minval ) {
             minval = val;
             mini = iter;
+            if ( minval <= clim.x ) {
+                // stop if no chance of finding a lower minval
+                iter = nsteps;
+            }
         }
         """,
     after_loop="""
         // Refine search for min value, but only if anything was found
         if ( mini > -1 ) {
-            loc = start_loc + step * (float(mini) - 0.5);
+            // Calculate starting location of ray for sampling
+            vec3 start_loc_refine = start_loc + step * (float(mini) - 0.5);
+            loc = start_loc_refine;
+
+            // Variables to keep track of current value and where max was encountered
+            vec3 min_loc_tex = start_loc_refine;
+
+            vec3 small_step = step * 0.1;
             for (int i=0; i<10; i++) {
-                minval = min(minval, $sample(u_volumetex, loc).r);
-                loc += step * 0.1;
+                float val = $get_data(loc).r;
+                if ( val < minval) {
+                    minval = val;
+                    min_loc_tex = start_loc_refine + (small_step * i);
+                }
+                loc += small_step;
             }
+            frag_depth_point = min_loc_tex * u_shape;
             gl_FragColor = applyColormap(minval);
+        } else {
+            discard;
         }
         """,
 )
@@ -442,24 +486,24 @@ _TRANSLUCENT_SNIPPETS = dict(
         vec4 integrated_color = vec4(0., 0., 0., 0.);
         """,
     in_loop="""
-            color = applyColormap(val);
-            float a1 = integrated_color.a;
-            float a2 = color.a * (1 - a1);
-            float alpha = max(a1 + a2, 0.001);
-
-            // Doesn't work.. GLSL optimizer bug?
-            //integrated_color = (integrated_color * a1 / alpha) +
-            //                   (color * a2 / alpha);
-            // This should be identical but does work correctly:
-            integrated_color *= a1 / alpha;
-            integrated_color += color * a2 / alpha;
-
-            integrated_color.a = alpha;
-
-            if( alpha > 0.99 ){
-                // stop integrating if the fragment becomes opaque
-                iter = nsteps;
-            }
+        color = applyColormap(val);
+        float a1 = integrated_color.a;
+        float a2 = color.a * (1 - a1);
+        float alpha = max(a1 + a2, 0.001);
+
+        // Doesn't work.. GLSL optimizer bug?
+        //integrated_color = (integrated_color * a1 / alpha) +
+        //                   (color * a2 / alpha);
+        // This should be identical but does work correctly:
+        integrated_color *= a1 / alpha;
+        integrated_color += color * a2 / alpha;
+
+        integrated_color.a = alpha;
+
+        if( alpha > 0.99 ){
+            // stop integrating if the fragment becomes opaque
+            iter = nsteps;
+        }
         """,
     after_loop="""
         gl_FragColor = integrated_color;
@@ -485,20 +529,21 @@ _ISO_SNIPPETS = dict(
         vec4 color3 = vec4(0.0);  // final color
         vec3 dstep = 1.5 / u_shape;  // step to sample derivative
         gl_FragColor = vec4(0.0);
+        bool discard_fragment = true;
     """,
     in_loop="""
         if (val > u_threshold-0.2) {
             // Take the last interval in smaller steps
             vec3 iloc = loc - step;
             for (int i=0; i<10; i++) {
-                color = $sample(u_volumetex, iloc);
+                color = $get_data(iloc);
                 if (color.r > u_threshold) {
                     color = calculateColor(color, iloc, dstep);
                     gl_FragColor = applyColormap(color.r);
 
                     // set the variables for the depth buffer
-                    surface_point = iloc * u_shape;
-                    surface_found = true;
+                    frag_depth_point = iloc * u_shape;
+                    discard_fragment = false;
 
                     iter = nsteps;
                     break;
@@ -508,12 +553,9 @@ _ISO_SNIPPETS = dict(
         }
         """,
     after_loop="""
-
-        if (!surface_found) {
+        if (discard_fragment)
             discard;
-        }
-
-        """,
+    """,
 )
 
 
@@ -535,6 +577,19 @@ _AVG_SNIPPETS = dict(
         """,
 )
 
+_INTERPOLATION_TEMPLATE = """
+    #include "misc/spatial-filters.frag"
+    vec4 texture_lookup_filtered(vec3 texcoord) {
+        // no need to discard out of bounds, already checked during raycasting
+        return %s($texture, $shape, texcoord);
+    }"""
+
+_TEXTURE_LOOKUP = """
+    vec4 texture_lookup(vec3 texcoord) {
+        // no need to discard out of bounds, already checked during raycasting
+        return texture3D($texture, texcoord);
+    }"""
+
 
 class VolumeVisual(Visual):
     """Displays a 3D Volume
@@ -567,8 +622,16 @@ class VolumeVisual(Visual):
     gamma : float
         Gamma to use during colormap lookup.  Final color will be cmap(val**gamma).
         by default: 1.
-    interpolation : {'linear', 'nearest'}
-        Selects method of image interpolation.
+    interpolation : str
+        Selects method of texture interpolation. Makes use of the two hardware
+        interpolation methods and the available interpolation methods defined
+        in vispy/gloo/glsl/misc/spatial_filters.frag
+
+            * 'nearest': Default, uses 'nearest' with Texture interpolation.
+            * 'linear': uses 'linear' with Texture interpolation.
+            * 'hanning', 'hamming', 'hermite', 'kaiser', 'quadric', 'cubic',
+                'catrom', 'mitchell', 'spline16', 'spline36', 'gaussian',
+                'bessel', 'sinc', 'lanczos', 'blackman'
     texture_format : numpy.dtype | str | None
         How to store data on the GPU. OpenGL allows for many different storage
         formats and schemes for the low-level texture data stored in the GPU.
@@ -615,8 +678,6 @@ class VolumeVisual(Visual):
 
     """
 
-    _interpolation_methods = ['linear', 'nearest']
-
     _rendering_methods = {
         'mip': _MIP_SNIPPETS,
         'minip': _MINIP_SNIPPETS,
@@ -637,12 +698,18 @@ class VolumeVisual(Visual):
         'fragment': _FRAGMENT_SHADER,
     }
 
+    _func_templates = {
+        'texture_lookup_interpolated': _INTERPOLATION_TEMPLATE,
+        'texture_lookup': _TEXTURE_LOOKUP,
+    }
+
     def __init__(self, vol, clim="auto", method='mip', threshold=None,
                  attenuation=1.0, relative_step_size=0.8, cmap='grays',
                  gamma=1.0, interpolation='linear', texture_format=None,
                  raycasting_mode='volume', plane_position=None,
                  plane_normal=None, plane_thickness=1.0, clipping_planes=None,
-                 clipping_planes_coord_system='scene'):
+                 clipping_planes_coord_system='scene', mip_cutoff=None,
+                 minip_cutoff=None):
 
         tr = ['visual', 'scene', 'document', 'canvas', 'framebuffer', 'render']
         if clipping_planes_coord_system not in tr:
@@ -661,7 +728,19 @@ class VolumeVisual(Visual):
         # Create gloo objects
         self._vertices = VertexBuffer()
 
+        kernel, interpolation_methods = load_spatial_filters()
+        self._kerneltex = Texture2D(kernel, interpolation='nearest')
+        interpolation_methods, interpolation_fun = self._init_interpolation(
+            interpolation_methods)
+        self._interpolation_methods = interpolation_methods
+        self._interpolation_fun = interpolation_fun
         self._interpolation = interpolation
+        if self._interpolation not in self._interpolation_methods:
+            raise ValueError("interpolation must be one of %s" %
+                             ', '.join(self._interpolation_methods))
+        self._data_lookup_fn = None
+        self._need_interpolation_update = True
+
         self._texture = self._create_texture(texture_format, vol)
         # used to store current data for later CPU-side scaling if
         # texture_format is None
@@ -685,6 +764,8 @@ class VolumeVisual(Visual):
 
         # Set params
         self.raycasting_mode = raycasting_mode
+        self.mip_cutoff = mip_cutoff
+        self.minip_cutoff = minip_cutoff
         self.method = method
         self.relative_step_size = relative_step_size
         self.threshold = threshold if threshold is not None else vol.mean()
@@ -705,17 +786,41 @@ class VolumeVisual(Visual):
 
         self.freeze()
 
+    def _init_interpolation(self, interpolation_methods):
+        # create interpolation shader functions for available
+        # interpolations
+        fun = [Function(self._func_templates['texture_lookup_interpolated'] % (n + '3D'))
+               for n in interpolation_methods]
+        interpolation_methods = [n.lower() for n in interpolation_methods]
+
+        interpolation_fun = dict(zip(interpolation_methods, fun))
+        interpolation_methods = tuple(sorted(interpolation_methods))
+
+        # overwrite "nearest" and "linear" spatial-filters
+        # with  "hardware" interpolation _data_lookup_fn
+        hardware_lookup = Function(self._func_templates['texture_lookup'])
+        interpolation_fun['nearest'] = hardware_lookup
+        interpolation_fun['linear'] = hardware_lookup
+        # alias bicubic to cubic (but deprecate)
+        interpolation_methods = interpolation_methods + ('bicubic',)
+        return interpolation_methods, interpolation_fun
+
     def _create_texture(self, texture_format, data):
         if texture_format is not None:
             tex_cls = GPUScaledTextured3D
         else:
             tex_cls = CPUScaledTexture3D
 
+        if self._interpolation == 'linear':
+            texture_interpolation = 'linear'
+        else:
+            texture_interpolation = 'nearest'
+
         # clamp_to_edge means any texture coordinates outside of 0-1 should be
         # clamped to 0 and 1.
         # NOTE: This doesn't actually set the data in the texture. Only
         # creates a placeholder texture that will be resized later on.
-        return tex_cls(data, interpolation=self._interpolation,
+        return tex_cls(data, interpolation=texture_interpolation,
                        internalformat=texture_format,
                        format='luminance',
                        wrapping='clamp_to_edge')
@@ -752,11 +857,9 @@ class VolumeVisual(Visual):
             self._texture.set_clim(clim)
 
         # Apply to texture
-        if should_cast_to_f32(vol.dtype):
-            vol = vol.astype(np.float32)
         self._texture.check_data_format(vol)
         self._last_data = vol
-        self._texture.scale_and_set_data(vol, copy=copy)  # will be efficient if vol is same shape
+        self._texture.scale_and_set_data(vol, copy=copy)
         self.shared_program['clim'] = self._texture.clim_normalized
         self.shared_program['u_shape'] = (vol.shape[2], vol.shape[1],
                                           vol.shape[0])
@@ -767,10 +870,6 @@ class VolumeVisual(Visual):
             self._need_vertex_update = True
         self._vol_shape = shape
 
-    @property
-    def interpolation_methods(self):
-        return self._interpolation_methods
-
     @property
     def rendering_methods(self):
         return list(self._rendering_methods)
@@ -828,56 +927,87 @@ class VolumeVisual(Visual):
         self.update()
 
     @property
-    def interpolation(self):
-        """The interpolation method to use
-
-        Current options are:
+    def interpolation_methods(self):
+        return self._interpolation_methods
 
-            * linear: this method is appropriate for most volumes as it creates
-              nice looking visuals.
-            * nearest: this method is appropriate for volumes with discrete
-              data where additional interpolation does not make sense.
-        """
+    @property
+    def interpolation(self):
+        """Get interpolation algorithm name."""
         return self._interpolation
 
     @interpolation.setter
-    def interpolation(self, interp):
-        if interp not in self._interpolation_methods:
-            raise ValueError(
-                "interpolation must be one of %s"
-                % ', '.join(self._interpolation_methods)
-            )
-        if self._interpolation != interp:
-            self._interpolation = interp
-            self._texture.interpolation = self._interpolation
+    def interpolation(self, i):
+        if i not in self._interpolation_methods:
+            raise ValueError("interpolation must be one of %s" %
+                             ', '.join(self._interpolation_methods))
+        if self._interpolation != i:
+            self._interpolation = i
+            self._need_interpolation_update = True
             self.update()
 
+    # The interpolation code could be transferred to a dedicated filter
+    # function in visuals/filters as discussed in #1051
+    def _build_interpolation(self):
+        """Rebuild the _data_lookup_fn for different interpolations."""
+        interpolation = self._interpolation
+        # alias bicubic to cubic
+        if interpolation == 'bicubic':
+            warnings.warn(
+                "'bicubic' interpolation is Deprecated. Use 'cubic' instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            interpolation = 'cubic'
+        self._data_lookup_fn = self._interpolation_fun[interpolation]
+        try:
+            self.shared_program.frag['get_data'] = self._data_lookup_fn
+        except Exception as e:
+            print(e)
+
+        # only 'linear' uses 'linear' texture interpolation
+        if interpolation == 'linear':
+            texture_interpolation = 'linear'
+        else:
+            # 'nearest' (and also 'linear') doesn't use spatial_filters.frag
+            # so u_kernel and shape setting is skipped
+            texture_interpolation = 'nearest'
+            if interpolation != 'nearest':
+                self.shared_program['u_kernel'] = self._kerneltex
+                self._data_lookup_fn['shape'] = self._last_data.shape[:3][::-1]
+
+        if self._texture.interpolation != texture_interpolation:
+            self._texture.interpolation = texture_interpolation
+
+        self._data_lookup_fn['texture'] = self._texture
+
+        self._need_interpolation_update = False
+
     @staticmethod
     @lru_cache(maxsize=10)
-    def _build_clipping_planes_func(n_planes):
+    def _build_clipping_planes_glsl(n_planes: int) -> str:
         """Build the code snippet used to clip the volume based on self.clipping_planes."""
         func_template = '''
             float clip_planes(vec3 loc, vec3 vol_shape) {{
-                vec3 loc_transf = $clip_transform(vec4(loc, 1)).xyz;
-                float distance_from_clip = 1.0;
+                vec3 loc_transf = $clip_transform(vec4(loc * vol_shape, 1)).xyz;
+                float distance_from_clip = 3.4e38; // max float
                 {clips};
                 return distance_from_clip;
             }}
         '''
         # the vertex is considered clipped if on the "negative" side of the plane
         clip_template = '''
-            vec3 relative_vec{idx} = loc_transf - ( $clipping_plane_pos{idx} / vol_shape );
-            float distance_from_clip{idx} = dot(relative_vec{idx}, ($clipping_plane_norm{idx} * vol_shape));
+            vec3 relative_vec{idx} = loc_transf - $clipping_plane_pos{idx};
+            float distance_from_clip{idx} = dot(relative_vec{idx}, $clipping_plane_norm{idx});
             distance_from_clip = min(distance_from_clip{idx}, distance_from_clip);
             '''
         all_clips = []
         for idx in range(n_planes):
             all_clips.append(clip_template.format(idx=idx))
         formatted_code = func_template.format(clips=''.join(all_clips))
-        return Function(formatted_code)
+        return formatted_code
 
     @property
-    def clipping_planes(self):
+    def clipping_planes(self) -> np.ndarray:
         """The set of planes used to clip the volume. Values on the negative side of the normal are discarded.
 
         Each plane is defined by a position and a normal vector (magnitude is irrelevant). Shape: (n_planes, 2, 3).
@@ -895,12 +1025,12 @@ class VolumeVisual(Visual):
         return self._clipping_planes
 
     @clipping_planes.setter
-    def clipping_planes(self, value):
+    def clipping_planes(self, value: Optional[np.ndarray]):
         if value is None:
             value = np.empty([0, 2, 3])
         self._clipping_planes = value
 
-        self._clip_func = self._build_clipping_planes_func(len(value))
+        self._clip_func = Function(self._build_clipping_planes_glsl(len(value)))
         self.shared_program.frag['clip_with_planes'] = self._clip_func
 
         self._clip_func['clip_transform'] = self._clip_transform
@@ -910,7 +1040,7 @@ class VolumeVisual(Visual):
         self.update()
 
     @property
-    def clipping_planes_coord_system(self):
+    def clipping_planes_coord_system(self) -> str:
         """
         Coordinate system used by the clipping planes (see visuals.transforms.transform_system.py)
         """
@@ -962,17 +1092,19 @@ class VolumeVisual(Visual):
                              (known_methods, method))
         self._method = method
 
-        # $sample needs to be unset and re-set, since it's present inside the snippets.
+        # $get_data needs to be unset and re-set, since it's present inside the snippets.
         #       Program should probably be able to do this automatically
-        self.shared_program.frag['sample'] = None
+        self.shared_program.frag['get_data'] = None
         self.shared_program.frag['raycasting_setup'] = self._raycasting_setup_snippet
         self.shared_program.frag['before_loop'] = self._before_loop_snippet
         self.shared_program.frag['in_loop'] = self._in_loop_snippet
         self.shared_program.frag['after_loop'] = self._after_loop_snippet
         self.shared_program.frag['sampler_type'] = self._texture.glsl_sampler_type
-        self.shared_program.frag['sample'] = self._texture.glsl_sample
         self.shared_program.frag['cmap'] = Function(self._cmap.glsl_map)
         self.shared_program['texture2D_LUT'] = self.cmap.texture_lut()
+        self.shared_program['u_mip_cutoff'] = self._mip_cutoff
+        self.shared_program['u_minip_cutoff'] = self._minip_cutoff
+        self._need_interpolation_update = True
         self.update()
 
     @property
@@ -1096,6 +1228,40 @@ class VolumeVisual(Visual):
         self.shared_program['u_plane_thickness'] = value
         self.update()
 
+    @property
+    def mip_cutoff(self):
+        """The lower cutoff value for `mip` and `attenuated_mip`.
+
+        When using the `mip` or `attenuated_mip` rendering methods, fragments
+        with values below the cutoff will be discarded.
+        """
+        return self._mip_cutoff
+
+    @mip_cutoff.setter
+    def mip_cutoff(self, value):
+        if value is None:
+            value = np.finfo('float32').min
+        self._mip_cutoff = float(value)
+        self.shared_program['u_mip_cutoff'] = self._mip_cutoff
+        self.update()
+
+    @property
+    def minip_cutoff(self):
+        """The upper cutoff value for `minip`.
+
+        When using the `minip` rendering method, fragments
+        with values above the cutoff will be discarded.
+        """
+        return self._minip_cutoff
+
+    @minip_cutoff.setter
+    def minip_cutoff(self, value):
+        if value is None:
+            value = np.finfo('float32').max
+        self._minip_cutoff = float(value)
+        self.shared_program['u_minip_cutoff'] = self._minip_cutoff
+        self.update()
+
     def _create_vertex_data(self):
         """Create and set positions and texture coords from the given shape
 
@@ -1164,3 +1330,6 @@ class VolumeVisual(Visual):
     def _prepare_draw(self, view):
         if self._need_vertex_update:
             self._create_vertex_data()
+
+        if self._need_interpolation_update:
+            self._build_interpolation()