vispy 0.14.3__cp311-cp311-macosx_11_0_arm64.whl → 0.15.2__cp311-cp311-macosx_11_0_arm64.whl

vispy/scene/widgets/grid.py

@@ -4,7 +4,11 @@
 """Grid widget for providing a gridded layout to child widgets."""
 
 from __future__ import division
+
+from typing import Tuple, Union, Dict
+
 import numpy as np
+from numpy.typing import NDArray
 
 from vispy.geometry import Rect
 from .widget import Widget
@@ -21,17 +25,19 @@ class Grid(Widget):
 
     Parameters
     ----------
-    spacing : int
-        Spacing between widgets.
+    spacing : int | tuple[int, int]
+        Spacing between widgets. If `tuple` then it must be of length two, the first element
+        being `width_spacing` and the second being `height_spacing`.
     **kwargs : dict
         Keyword arguments to pass to `Widget`.
     """
 
-    def __init__(self, spacing=6, **kwargs):
+    def __init__(self, spacing=0, **kwargs):
         """Create solver and basic grid parameters."""
         self._next_cell = [0, 0]  # row, col
         self._cells = {}
         self._grid_widgets = {}
+
         self.spacing = spacing
         self._n_added = 0
         self._default_class = ViewBox  # what to add when __getitem__ is used
@@ -45,9 +51,6 @@ class Grid(Widget):
         self._width_grid = None
         self._height_grid = None
 
-        # self._height_stay = None
-        # self._width_stay = None
-
         Widget.__init__(self, **kwargs)
 
     def __getitem__(self, idxs):
@@ -256,53 +259,129 @@ class Grid(Widget):
             locs[r:r + rs, c:c + cs] = key
         return locs
 
+    @property
+    def spacing(self):
+        """
+        The spacing between individual Viewbox widgets in the grid.
+        """
+        return self._spacing
+
+    @spacing.setter
+    def spacing(self, value: Union[int, Tuple[int, int]]):
+        if not (
+            isinstance(value, int)
+            or isinstance(value, tuple)
+            and len(value) == 2
+            and isinstance(value[0], int)
+            and isinstance(value[1], int)
+        ):
+            raise ValueError('spacing must be of type int | tuple[int, int]')
+
+        self._spacing = value
+        self._need_solver_recreate = True
+
     def __repr__(self):
         return (('<Grid at %s:\n' % hex(id(self))) +
                 str(self.layout_array + 1) + '>')
 
     @staticmethod
-    def _add_total_width_constraints(solver, width_grid, _var_w):
-        for ws in width_grid:
-            width_expr = ws[0]
-            for w in ws[1:]:
-                width_expr += w
-            solver.addConstraint(width_expr == _var_w)
+    def _add_total_dim_length_constraints(solver: Solver, grid_dim_variables: NDArray[Variable],
+                                          n_added: int, _var_dim_length: Variable, spacing: float):
+        """Add constraint: total height == sum(col heights) + sum(spacing).
 
-    @staticmethod
-    def _add_total_height_constraints(solver, height_grid, _var_h):
-        for hs in height_grid:
-            height_expr = hs[0]
-            for h in hs[1:]:
-                height_expr += h
-            solver.addConstraint(height_expr == _var_h)
+        The total height of the grid is constrained to be equal to the sum of the heights of
+        its columns, including spacing between widgets.
+
+        Parameters
+        ----------
+        solver: Solver
+            Solver for a system of linear equations.
+        grid_dim_variables: NDArray[Variable]:
+            The grid of width or height variables of either shape col * row or row * col with each element being a
+            Variable in the solver representing the height or width of each grid box.
+        n_added: int
+            The number of ViewBoxes added to the grid.
+        _var_dim_length: Variable
+            The solver variable representing either total width or height of the grid.
+        spacing: float
+            The amount of spacing between single adjacent Viewbox widgets in the grid.
+        """
+        total_spacing = 0
+        if n_added > 1:
+            for _ in range(grid_dim_variables.shape[1] - 1):
+                total_spacing += spacing
+
+        for ds in grid_dim_variables:
+            dim_length_expr = ds[0]
+            for d in ds[1:]:
+                dim_length_expr += d
+            dim_length_expr += total_spacing
+            solver.addConstraint(dim_length_expr == _var_dim_length)
 
     @staticmethod
-    def _add_gridding_width_constraints(solver, width_grid):
+    def _add_gridding_dim_constraints(solver: Solver, grid_dim_variables: NDArray[Variable]):
+        """Add constraint: all viewbox dims in each dimension are equal.
+
+        With all dims the reserved space for a widget with a col_span and row_span of 1 is meant, e.g. we have 3
+        widgets arranged in columns or rows with col_span or row_span 1 and those are being constrained to all be of
+        width/height 100. In other words the same dim length is reserved for each position in the grid, not taking
+        into account the spacing between grid positions.
+
+        Parameters
+        ----------
+        solver: Solver
+            Solver for a system of linear equations.
+        grid_dim_variables:
+            The grid of width or height variables of either shape col * row or row * col with each element being a
+            Variable in the solver representing the height or width of each grid box.
+        """
         # access widths of one "y", different x
-        for ws in width_grid.T:
-            for w in ws[1:]:
-                solver.addConstraint(ws[0] == w)
+        for ds in grid_dim_variables.T:
+            for d in ds[1:]:
+                solver.addConstraint(ds[0] == d)
 
     @staticmethod
-    def _add_gridding_height_constraints(solver, height_grid):
-        # access heights of one "y"
-        for hs in height_grid.T:
-            for h in hs[1:]:
-                solver.addConstraint(hs[0] == h)
+    def _add_stretch_constraints(solver: Solver, width_grid: NDArray[Variable] , height_grid: NDArray[Variable],
+                                 grid_widgets: Dict[int, Tuple[int, int, int, int, ViewBox]],
+                                 widget_grid: NDArray[ViewBox]):
+        """
+        Add proportional stretch constraints to the linear system solver of the grid.
 
-    @staticmethod
-    def _add_stretch_constraints(solver, width_grid, height_grid,
-                                 grid_widgets, widget_grid):
+        This method enforces that grid rows and columns stretch in proportion
+        to the widgets' specified stretch factors. It uses weak constraints
+        so that proportionality is preserved when possible but can be violated
+        if stronger layout constraints are present.
+
+        Parameters
+        ----------
+        solver : Solver
+            Solver for a system of linear equations.
+        width_grid : NDArray[Variable]
+            The grid of width variables in the linear system of equations to be solved.
+        height_grid : NDArray[Variable]
+            The grid of height variables in the linear system of equations to be solved.
+        grid_widgets : dict[int, tuple[int, int, int, int, ViewBox]]
+            Dictionary mapping order of viewboxes added as int to their grid layout description:
+            (start_y, start_x, span_y, span_x, ViewBox).
+        widget_grid : NDArray[ViewBox]
+            Array of viewboxes in shape n_columns x n_rows.
+
+        Notes
+        -----
+        - Stretch constraints are added with 'weak' strength, allowing them to
+          be overridden by stronger constraints such as fixed sizes or min/max bounds.
+        - The constraint `total_size / stretch_factor` is used to maintain
+          proportional relationships among rows and columns.
+        """
         xmax = len(height_grid)
         ymax = len(width_grid)
 
-        stretch_widths = [[] for _ in range(0, ymax)]
-        stretch_heights = [[] for _ in range(0, xmax)]
+        stretch_widths = [[] for _ in range(ymax)]
+        stretch_heights = [[] for _ in range(xmax)]
 
         for (y, x, ys, xs, widget) in grid_widgets.values():
             for ws in width_grid[y:y+ys]:
                 total_w = np.sum(ws[x:x+xs])
-
                 for sw in stretch_widths[y:y+ys]:
                     sw.append((total_w, widget.stretch[0]))
 
@@ -339,14 +418,36 @@ class Grid(Widget):
                                      'weak')
 
     @staticmethod
-    def _add_widget_dim_constraints(solver, width_grid, height_grid,
-                                    total_var_w, total_var_h, grid_widgets):
+    def _add_widget_dim_constraints(solver: Solver, width_grid: NDArray[Variable], height_grid: NDArray[Variable],
+                                    total_var_w: Variable, total_var_h: Variable,
+                                    grid_widgets: Dict[int, Tuple[int, int, int, int, ViewBox]]):
+        """Add constraints based on min/max width/height of widgets.
+
+        These constraints ensure that each widget's dimensions stay within its
+        specified minimum and maximum values.
+
+        Parameters
+        ----------
+        solver : Solver
+            Solver for a system of linear equations.
+        width_grid : NDArray[Variable]
+            The grid of width variables in the linear system of equations to be solved.
+        height_grid : NDArray[Variable]
+            The grid of height variables in the linear system of equations to be solved.
+        total_var_w : Variable
+            The Variable representing the total width of the grid in the linear system of equations.
+        total_var_w : Variable
+            The Variable representing the total height of the grid in the linear system of equations.
+        grid_widgets : dict[int, tuple[int, int, int, int, ViewBox]]
+            Dictionary mapping order of viewboxes added as int to their grid layout description:
+            (start_y, start_x, span_y, span_x, ViewBox).
+                """
         assert(total_var_w is not None)
         assert(total_var_h is not None)
 
         for ws in width_grid:
             for w in ws:
-                solver.addConstraint(w >= 0,)
+                solver.addConstraint(w >= 0)
 
         for hs in height_grid:
             for h in hs:
@@ -375,6 +476,7 @@ class Grid(Widget):
                     solver.addConstraint(total_h <= total_var_h)
 
     def _recreate_solver(self):
+        """Recreate the linear system solver with all constraints."""
         self._solver.reset()
         self._var_w = Variable("w_rect")
         self._var_h = Variable("h_rect")
@@ -390,43 +492,40 @@ class Grid(Widget):
         self._solver.addConstraint(self._var_w >= 0)
         self._solver.addConstraint(self._var_h >= 0)
 
-        # self._height_stay = None
-        # self._width_stay = None
-
         # add widths
-        self._width_grid = np.array([[Variable("width(x: %s, y: %s)" % (x, y))
-                                      for x in range(0, xmax)]
-                                     for y in range(0, ymax)])
+        self._width_grid = np.array(
+            [
+                [Variable(f"width(x: {x}, y: {y})") for x in range(xmax)]
+                for y in range(ymax)
+            ]
+        )
 
         # add heights
-        self._height_grid = np.array([[Variable("height(x: %s, y: %s" % (x, y))
-                                       for y in range(0, ymax)]
-                                      for x in range(0, xmax)])
-
-        # setup stretch
-        stretch_grid = np.zeros(shape=(xmax, ymax, 2), dtype=float)
-        stretch_grid.fill(1)
-
-        for (_, val) in self._grid_widgets.items():
-            (y, x, ys, xs, widget) = val
-            stretch_grid[x:x+xs, y:y+ys] = widget.stretch
-
+        self._height_grid = np.array(
+            [
+                [Variable(f"height(x: {x}, y: {y})") for y in range(ymax)]
+                for x in range(xmax)
+            ]
+        )
+
+        if isinstance(self.spacing, tuple):
+            width_spacing, height_spacing = self.spacing
+        else:
+            width_spacing = height_spacing = self.spacing
         # even though these are REQUIRED, these should never fail
         # since they're added first, and thus the slack will "simply work".
-        Grid._add_total_width_constraints(self._solver,
-                                          self._width_grid, self._var_w)
-        Grid._add_total_height_constraints(self._solver,
-                                           self._height_grid, self._var_h)
+        Grid._add_total_dim_length_constraints(self._solver,
+                                          self._width_grid, self._n_added, self._var_w, width_spacing)
+        Grid._add_total_dim_length_constraints(self._solver,
+                                           self._height_grid, self._n_added, self._var_h, height_spacing)
 
         try:
             # these are REQUIRED constraints for width and height.
             # These are the constraints which can fail if
             # the corresponding dimension of the widget cannot be fit in the
             # grid.
-            Grid._add_gridding_width_constraints(self._solver,
-                                                 self._width_grid)
-            Grid._add_gridding_height_constraints(self._solver,
-                                                  self._height_grid)
+            Grid._add_gridding_dim_constraints(self._solver, self._width_grid)
+            Grid._add_gridding_dim_constraints(self._solver, self._height_grid)
         except UnsatisfiableConstraint:
             self._need_solver_recreate = True
 
@@ -436,24 +535,27 @@ class Grid(Widget):
                                       self._width_grid,
                                       self._height_grid,
                                       self._grid_widgets,
-                                      self._widget_grid)
+                                      self._widget_grid,
+                                      )
 
         Grid._add_widget_dim_constraints(self._solver,
                                          self._width_grid,
                                          self._height_grid,
                                          self._var_w,
                                          self._var_h,
-                                         self._grid_widgets)
+                                         self._grid_widgets
+                                         )
 
         self._solver.updateVariables()
 
     def _update_child_widget_dim(self):
+        """Solve the linear system of equations in order to assign Viewbox parameters such as position."""
         # think in terms of (x, y). (row, col) makes code harder to read
         ymax, xmax = self.grid_size
         if ymax <= 0 or xmax <= 0:
             return
 
-        rect = self.rect  # .padded(self.padding + self.margin)
+        rect = self.rect.padded(self.padding + self.margin)
         if rect.width <= 0 or rect.height <= 0:
             return
         if self._need_solver_recreate:
@@ -474,22 +576,40 @@ class Grid(Widget):
 
         value_vectorized = np.vectorize(lambda x: x.value())
 
-        for (_, val) in self._grid_widgets.items():
+        if isinstance(self.spacing, tuple):
+            width_spacing, height_spacing = self.spacing
+        else:
+            width_spacing = height_spacing = self.spacing
+
+        for index, (_, val) in enumerate(self._grid_widgets.items()):
             (row, col, rspan, cspan, widget) = val
 
+            # If spacing, always one spacing unit between 2 grid positions, even when span is > 1.
+            # If span is > 1, spacing will be added to the dim length of Viewbox
+            spacing_width_offset = col * width_spacing if self._n_added > 1 else 0
+            spacing_height_offset = row * height_spacing if self._n_added > 1 else 0
+
+            # Add one spacing unit to dim length of the Viewbox per grid positions the ViewBox spans if span > 1.
+            width_increase_spacing = width_spacing * (cspan - 1)
+            height_increase_spacing = height_spacing * (rspan - 1)
+
             width = np.sum(value_vectorized(
-                           self._width_grid[row][col:col+cspan]))
+                           self._width_grid[row][col:col+cspan])) + width_increase_spacing
             height = np.sum(value_vectorized(
-                            self._height_grid[col][row:row+rspan]))
+                            self._height_grid[col][row:row+rspan])) + height_increase_spacing
+
             if col == 0:
                 x = 0
             else:
-                x = np.sum(value_vectorized(self._width_grid[row][0:col]))
+                x = np.sum(value_vectorized(self._width_grid[row][:col])) + spacing_width_offset
 
             if row == 0:
                 y = 0
             else:
-                y = np.sum(value_vectorized(self._height_grid[col][0:row]))
+                y = np.sum(value_vectorized(self._height_grid[col][:row])) + spacing_height_offset
+
+            x += self.padding
+            y += self.padding
 
             if isinstance(widget, ViewBox):
                 widget.rect = Rect(x, y, width, height)

vispy/scene/widgets/widget.py

@@ -312,6 +312,17 @@ class Widget(Compound):
         self._update_line()
         self.update()
 
+    @property
+    def border_width(self):
+        """The width of the border."""
+        return self._border_width
+
+    @border_width.setter
+    def border_width(self, b):
+        self._border_width = float(b)
+        self._update_line()
+        self.update()
+
     @property
     def bgcolor(self):
         """The background color of the Widget."""

vispy/version.py

@@ -1,8 +1,13 @@
-# file generated by setuptools_scm
+# file generated by setuptools-scm
 # don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
 TYPE_CHECKING = False
 if TYPE_CHECKING:
-    from typing import Tuple, Union
+    from typing import Tuple
+    from typing import Union
+
     VERSION_TUPLE = Tuple[Union[int, str], ...]
 else:
     VERSION_TUPLE = object
@@ -12,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.14.3'
-__version_tuple__ = version_tuple = (0, 14, 3)
+__version__ = version = '0.15.2'
+__version_tuple__ = version_tuple = (0, 15, 2)

vispy/visuals/_scalable_textures.py

@@ -291,10 +291,11 @@ class CPUScaledTextureMixin(_ScaledTextureMixin):
 
         range_min, range_max = self._data_limits
         clim_min, clim_max = self.clim
-        if clim_min == clim_max:
+        full_range = range_max - range_min
+        if clim_min == clim_max or full_range == 0:
             return 0, np.inf
-        clim_min = (clim_min - range_min) / (range_max - range_min)
-        clim_max = (clim_max - range_min) / (range_max - range_min)
+        clim_min = (clim_min - range_min) / full_range
+        clim_max = (clim_max - range_min) / full_range
         return clim_min, clim_max
 
     @staticmethod
@@ -312,7 +313,7 @@ class CPUScaledTextureMixin(_ScaledTextureMixin):
     def scale_and_set_data(self, data, offset=None, copy=True):
         """Upload new data to the GPU, scaling if necessary."""
         if self._data_dtype is None:
-            data.dtype == self._data_dtype
+            self._data_dtype = data.dtype
 
         # ensure dtype is the same as it was before, or funny things happen
         # no copy is performed unless asked for or necessary

vispy/visuals/filters/mesh.py

@@ -421,6 +421,7 @@ class ShadingFilter(Filter):
         ffunc = Function(self._shaders['fragment'])
 
         self._normals = VertexBuffer(np.zeros((0, 3), dtype=np.float32))
+        self._normals_cache = None
         vfunc['normal'] = self._normals
 
         super().__init__(vcode=vfunc, fcode=ffunc)
@@ -550,7 +551,11 @@ class ShadingFilter(Filter):
         )
 
         normals = self._visual.mesh_data.get_vertex_normals(indexed='faces')
-        self._normals.set_data(normals, convert=True)
+        if normals is not self._normals_cache:
+            # limit how often we upload new normal arrays
+            # gotcha: if normals are changed in place then this won't invalidate this cache
+            self._normals_cache = normals
+            self._normals.set_data(self._normals_cache, convert=True)
 
     def on_mesh_data_updated(self, event):
         self._update_data()

vispy/visuals/gridlines.py

@@ -4,27 +4,31 @@
 
 from __future__ import division
 
+import numpy as np
+
 from .image import ImageVisual
 from ..color import Color
 from .shaders import Function
 
 
 _GRID_COLOR = """
+uniform vec4 u_gridlines_bounds;
+uniform float u_border_width;
+
 vec4 grid_color(vec2 pos) {
     vec4 px_pos = $map_to_doc(vec4(pos, 0, 1));
     px_pos /= px_pos.w;
 
     // Compute vectors representing width, height of pixel in local coords
-    float s = 1.;
     vec4 local_pos = $map_doc_to_local(px_pos);
-    vec4 dx = $map_doc_to_local(px_pos + vec4(1.0 / s, 0, 0, 0));
-    vec4 dy = $map_doc_to_local(px_pos + vec4(0, 1.0 / s, 0, 0));
+    vec4 dx = $map_doc_to_local(px_pos + vec4(1.0, 0, 0, 0));
+    vec4 dy = $map_doc_to_local(px_pos + vec4(0, 1.0, 0, 0));
     local_pos /= local_pos.w;
     dx = dx / dx.w - local_pos;
     dy = dy / dy.w - local_pos;
 
     // Pixel length along each axis, rounded to the nearest power of 10
-    vec2 px = s * vec2(abs(dx.x) + abs(dy.x), abs(dx.y) + abs(dy.y));
+    vec2 px = vec2(abs(dx.x) + abs(dy.x), abs(dx.y) + abs(dy.y));
     float log10 = log(10.0);
     float sx = pow(10.0, floor(log(px.x) / log10) + 1.) * $scale.x;
     float sy = pow(10.0, floor(log(px.y) / log10) + 1.) * $scale.y;
@@ -57,6 +61,17 @@ vec4 grid_color(vec2 pos) {
     if (alpha == 0.) {
         discard;
     }
+
+    if (any(lessThan(local_pos.xy + u_border_width / 2, u_gridlines_bounds.xz)) ||
+        any(greaterThan(local_pos.xy - u_border_width / 2, u_gridlines_bounds.yw))) {
+        discard;
+    }
+
+    if (any(lessThan(local_pos.xy - u_gridlines_bounds.xz, vec2(u_border_width / 2))) ||
+        any(lessThan(u_gridlines_bounds.yw - local_pos.xy, vec2(u_border_width / 2)))) {
+        alpha = 1;
+    }
+
     return vec4($color.rgb, $color.a * alpha);
 }
 """
@@ -73,9 +88,16 @@ class GridLinesVisual(ImageVisual):
     color : Color
         The base color for grid lines. The final color may have its alpha
         channel modified.
+    grid_bounds : tuple or None
+        The lower and upper bound for each axis beyond which no grid is rendered.
+        In the form of (minx, maxx, miny, maxy).
+    border_width : float
+        Tickness of the border rendered at the bounds of the grid.
     """
 
-    def __init__(self, scale=(1, 1), color='w'):
+    def __init__(self, scale=(1, 1), color='w',
+                 grid_bounds=None,
+                 border_width=2):
         # todo: PlaneVisual should support subdivide/impostor methods from
         # image and gridlines should inherit from plane instead.
         self._grid_color_fn = Function(_GRID_COLOR)
@@ -86,6 +108,40 @@ class GridLinesVisual(ImageVisual):
         self.shared_program.frag['get_data'] = self._grid_color_fn
         cfun = Function('vec4 null(vec4 x) { return x; }')
         self.shared_program.frag['color_transform'] = cfun
+        self.unfreeze()
+        self.grid_bounds = grid_bounds
+        self.border_width = border_width
+        self.freeze()
+
+    @property
+    def grid_bounds(self):
+        return self._grid_bounds
+
+    @grid_bounds.setter
+    def grid_bounds(self, value):
+        if value is None:
+            value = (None,) * 4
+        grid_bounds = []
+        for i, v in enumerate(value):
+            if v is None:
+                if i % 2:
+                    v = -np.inf
+                else:
+                    v = np.inf
+            grid_bounds.append(v)
+        self.shared_program['u_gridlines_bounds'] = value
+        self._grid_bounds = grid_bounds
+        self.update()
+
+    @property
+    def border_width(self):
+        return self._border_width
+
+    @border_width.setter
+    def border_width(self, value):
+        self.shared_program['u_border_width'] = value
+        self._border_width = value
+        self.update()
 
     @property
     def size(self):

vispy/visuals/image.py

@@ -91,11 +91,9 @@ _TEXTURE_LOOKUP = """
 
 _APPLY_CLIM_FLOAT = """
     float apply_clim(float data) {
-        // If data is NaN, don't draw it at all
-        // http://stackoverflow.com/questions/11810158/how-to-deal-with-nan-or-inf-in-opengl-es-2-0-shaders
-        if (!(data <= 0.0 || 0.0 <= data)) {
-            discard;
-        }
+        // pass through NaN values to get handled by the colormap
+        if (!(data <= 0.0 || 0.0 <= data)) return data;
+
         data = clamp(data, min($clim.x, $clim.y), max($clim.x, $clim.y));
         data = (data - $clim.x) / ($clim.y - $clim.x);
         return data;
@@ -103,7 +101,7 @@ _APPLY_CLIM_FLOAT = """
 
 _APPLY_CLIM = """
     vec4 apply_clim(vec4 color) {
-        // Handle NaN values
+        // Handle NaN values (clamp them to the minimum value)
         // http://stackoverflow.com/questions/11810158/how-to-deal-with-nan-or-inf-in-opengl-es-2-0-shaders
         color.r = !(color.r <= 0.0 || 0.0 <= color.r) ? min($clim.x, $clim.y) : color.r;
         color.g = !(color.g <= 0.0 || 0.0 <= color.g) ? min($clim.x, $clim.y) : color.g;
@@ -117,6 +115,9 @@ _APPLY_CLIM = """
 
 _APPLY_GAMMA_FLOAT = """
     float apply_gamma(float data) {
+        // pass through NaN values to get handled by the colormap
+        if (!(data <= 0.0 || 0.0 <= data)) return data;
+
         return pow(data, $gamma);
     }"""
 
@@ -129,7 +130,7 @@ _APPLY_GAMMA = """
 
 _NULL_COLOR_TRANSFORM = 'vec4 pass(vec4 color) { return color; }'
 
-_C2L_RED = 'float cmap(vec4 color) { return color.r; }'
+_C2L_RED = 'float color_to_luminance(vec4 color) { return color.r; }'
 
 _CUSTOM_FILTER = """
 vec4 texture_lookup(vec2 texcoord) {
@@ -456,6 +457,17 @@ class ImageVisual(Visual):
             self.shared_program.frag['color_transform'][2]['gamma'] = self._gamma
         self.update()
 
+    @property
+    def bad_color(self):
+        """Color used to render NaN values."""
+        return self._cmap.get_bad_color()
+
+    @bad_color.setter
+    def bad_color(self, color):
+        self._cmap.set_bad_color(color)
+        self._need_colortransform_update = True
+        self.update()
+
     @property
     def method(self):
         """Get rendering method name."""

vispy/visuals/surface_plot.py

@@ -126,7 +126,7 @@ class SurfacePlotVisual(MeshVisual):
             # convert (width, height, 4) to (num_verts, 4)
             vert_shape = self.__vertices.shape
             num_vertices = vert_shape[0] * vert_shape[1]
-            colors = colors.reshape(num_vertices, 3)
+            colors = colors.reshape(num_vertices, colors.shape[-1])
         return colors
 
     def set_data(self, x=None, y=None, z=None, colors=None):