vispy 0.14.3__cp39-cp39-macosx_11_0_arm64.whl → 0.15.1__cp39-cp39-macosx_11_0_arm64.whl

vispy/gloo/program.py

@@ -362,7 +362,7 @@ class Program(GLObject):
                         data = TextureCube(data)
                     else:
                         # This should not happen
-                        raise RuntimeError('Unknown type %s' % type_)
+                        raise RuntimeError('Unknown type %s for %s' % (type_, name))
                     # Store and send GLIR command
                     self._user_variables[name] = data
                     self.glir.associate(data.glir)
@@ -442,7 +442,7 @@ class Program(GLObject):
                     self._glir.command('ATTRIBUTE', self._id,
                                        name, type_, value, divisor)
             else:
-                raise KeyError('Cannot set data for a %s.' % kind)
+                raise KeyError('Cannot set data for a %s (%s).' % (kind, name))
         else:
             # This variable is not defined in the current source code,
             # so we cannot establish whether this is a uniform or

vispy/scene/cameras/arcball.py

@@ -6,7 +6,6 @@ from __future__ import division
 
 import numpy as np
 
-
 from ...util import transforms
 from ...util.quaternion import Quaternion
 from ...visuals.transforms import MatrixTransform
@@ -57,7 +56,7 @@ class ArcballCamera(Base3DRotationCamera):
 
     def _update_rotation(self, event):
         """Update rotation parmeters based on mouse movement"""
-        p2 = event.mouse_event.pos
+        p2 = event.pos[:2]
         if self._event_value is None:
             self._event_value = p2
         wh = self._viewbox.size

vispy/scene/cameras/base_camera.py

@@ -3,6 +3,7 @@
 # Distributed under the (new) BSD License. See LICENSE.txt for more info.
 
 from __future__ import division
+from contextlib import contextmanager
 
 from ...util import keys
 from ..node import Node
@@ -211,11 +212,14 @@ class BaseCamera(Node):
     @center.setter
     def center(self, val):
         if len(val) == 2:
-            self._center = float(val[0]), float(val[1]), 0.0
+            center = float(val[0]), float(val[1]), 0.0
         elif len(val) == 3:
-            self._center = float(val[0]), float(val[1]), float(val[2])
+            center = float(val[0]), float(val[1]), float(val[2])
         else:
             raise ValueError('Center must be a 2 or 3 element tuple')
+        if center == self._center:
+            return
+        self._center = center
         self.view_changed()
 
     @property
@@ -233,6 +237,12 @@ class BaseCamera(Node):
         self._fov = fov
         self.view_changed()
 
+    @contextmanager
+    def _block_updates(self):
+        prev, self._resetting = self._resetting, True
+        yield
+        self._resetting = prev
+
     # Camera methods
 
     def set_range(self, x=None, y=None, z=None, margin=0.05):
@@ -276,31 +286,30 @@ class BaseCamera(Node):
             return
 
         # There is a viewbox, we're going to set the range for real
-        self._resetting = True
+        with self._block_updates():
 
-        # Get bounds from viewbox if not given
-        if all([(b is None) for b in bounds]):
-            bounds = self._viewbox.get_scene_bounds()
-        else:
-            for i in range(3):
-                if bounds[i] is None:
-                    bounds[i] = self._viewbox.get_scene_bounds(i)
-
-        # Calculate ranges and margins
-        ranges = [b[1] - b[0] for b in bounds]
-        margins = [(r*margin or 0.1) for r in ranges]
-        # Assign limits for this camera
-        bounds_margins = [(b[0]-m, b[1]+m) for b, m in zip(bounds, margins)]
-        self._xlim, self._ylim, self._zlim = bounds_margins
-        # Store center location
-        if (not init) or (self._center is None):
-            self._center = [(b[0] + r / 2) for b, r in zip(bounds, ranges)]
-
-        # Let specific camera handle it
-        self._set_range(init)
+            # Get bounds from viewbox if not given
+            if all([(b is None) for b in bounds]):
+                bounds = self._viewbox.get_scene_bounds()
+            else:
+                for i in range(3):
+                    if bounds[i] is None:
+                        bounds[i] = self._viewbox.get_scene_bounds(i)
+
+            # Calculate ranges and margins
+            ranges = [b[1] - b[0] for b in bounds]
+            margins = [(r*margin or 0.1) for r in ranges]
+            # Assign limits for this camera
+            bounds_margins = [(b[0]-m, b[1]+m) for b, m in zip(bounds, margins)]
+            self._xlim, self._ylim, self._zlim = bounds_margins
+            # Store center location
+            if (not init) or (self._center is None):
+                self._center = [(b[0] + r / 2) for b, r in zip(bounds, ranges)]
+
+            # Let specific camera handle it
+            self._set_range(init)
 
         # Finish
-        self._resetting = False
         self.view_changed()
 
     def _set_range(self, init):
@@ -357,32 +366,34 @@ class BaseCamera(Node):
         state = state or {}
         state.update(kwargs)
 
-        # In first pass, process tuple keys which select subproperties. This
-        # is an undocumented feature used for selective linking of camera state.
-        #
-        # Subproperties are handled by first copying old value of the root
-        # property, then setting the subproperty on this copy, and finally
-        # assigning the copied object back to the camera property. There needs
-        # to be an assignment of the root property so setters are called and
-        # update is triggered.
-        for key in list(state.keys()):
-            if isinstance(key, tuple):
-                key1 = key[0]
-                if key1 not in state:
-                    root_prop = getattr(self, key1)
-                    # We make copies by passing the old object to the type's
-                    # constructor. This needs to be supported as is the case in
-                    # e.g. the geometry.Rect class.
-                    state[key1] = root_prop.__class__(root_prop)
-                nested_setattr(state[key1], key[1:], state[key])
-
-        # In second pass, assign the new root properties.
-        for key, val in state.items():
-            if isinstance(key, tuple):
-                continue
-            if key not in self._state_props:
-                raise KeyError('Not a valid camera state property %r' % key)
-            setattr(self, key, val)
+        with self._block_updates():
+            # In first pass, process tuple keys which select subproperties. This
+            # is an undocumented feature used for selective linking of camera state.
+            #
+            # Subproperties are handled by first copying old value of the root
+            # property, then setting the subproperty on this copy, and finally
+            # assigning the copied object back to the camera property. There needs
+            # to be an assignment of the root property so setters are called and
+            # update is triggered.
+            for key in list(state.keys()):
+                if isinstance(key, tuple):
+                    key1 = key[0]
+                    if key1 not in state:
+                        root_prop = getattr(self, key1)
+                        # We make copies by passing the old object to the type's
+                        # constructor. This needs to be supported as is the case in
+                        # e.g. the geometry.Rect class.
+                        state[key1] = root_prop.__class__(root_prop)
+                    nested_setattr(state[key1], key[1:], state[key])
+
+            # In second pass, assign the new root properties.
+            for key, val in state.items():
+                if isinstance(key, tuple):
+                    continue
+                if key not in self._state_props:
+                    raise KeyError('Not a valid camera state property %r' % key)
+                setattr(self, key, val)
+        self.view_changed()
 
     def link(self, camera, props=None, axis=None):
         """Link this camera with another camera of the same type
@@ -508,6 +519,8 @@ class BaseCamera(Node):
 
     def _set_scene_transform(self, tr):
         """Called by subclasses to configure the viewbox scene transform."""
+        if self._resetting:
+            return
         # todo: check whether transform has changed, connect to
         # transform.changed event
         pre_tr = self.pre_transform

vispy/scene/cameras/panzoom.py

@@ -164,7 +164,7 @@ class PanZoomCamera(BaseCamera):
     def center(self, center):
         if not (isinstance(center, (tuple, list)) and len(center) in (2, 3)):
             raise ValueError('center must be a 2 or 3 element tuple')
-        rect = Rect(self.rect) or Rect(*DEFAULT_RECT_TUPLE)
+        rect = Rect(self.rect) or Rect(*DEFAULT_RECT_TUPLE)  # make a copy of self.rect
         rect.center = center[:2]
         self.rect = rect
 
@@ -246,6 +246,9 @@ class PanZoomCamera(BaseCamera):
             event.handled = False
 
     def _update_transform(self):
+        if self._resetting:  # base camera linking operation
+            return
+
         rect = self.rect
         self._real_rect = Rect(rect)
         vbr = self._viewbox.rect.flipped(x=self.flip[0], y=(not self.flip[1]))

vispy/scene/cameras/perspective.py

@@ -80,7 +80,10 @@ class PerspectiveCamera(BaseCamera):
 
     @scale_factor.setter
     def scale_factor(self, value):
-        self._scale_factor = abs(float(value))
+        value = abs(float(value))
+        if value == self._scale_factor:
+            return
+        self._scale_factor = value
         self.view_changed()
 
     @property
@@ -137,6 +140,8 @@ class PerspectiveCamera(BaseCamera):
         # Do we have a viewbox
         if self._viewbox is None:
             return
+        if self._resetting:  # base camera linking operation
+            return
 
         # Calculate viewing range for x and y
         fx = fy = self._scale_factor

vispy/scene/cameras/turntable.py

@@ -73,6 +73,9 @@ class TurntableCamera(Base3DRotationCamera):
         super(TurntableCamera, self).__init__(fov=fov, **kwargs)
 
         # Set camera attributes
+        self._azimuth = azimuth
+        self._elevation = elevation
+        self._roll = roll
         self.azimuth = azimuth
         self.elevation = elevation
         self.roll = roll
@@ -90,7 +93,10 @@ class TurntableCamera(Base3DRotationCamera):
     @elevation.setter
     def elevation(self, elev):
         elev = float(elev)
-        self._elevation = min(90, max(-90, elev))
+        elev = min(90, max(-90, elev))
+        if elev == self._elevation:
+            return
+        self._elevation = elev
         self.view_changed()
 
     @property
@@ -108,6 +114,8 @@ class TurntableCamera(Base3DRotationCamera):
             azim += 360
         while azim > 180:
             azim -= 360
+        if azim == self._azimuth:
+            return
         self._azimuth = azim
         self.view_changed()
 
@@ -123,6 +131,8 @@ class TurntableCamera(Base3DRotationCamera):
             roll += 360
         while roll > 180:
             roll -= 360
+        if roll == self._roll:
+            return
         self._roll = roll
         self.view_changed()
 

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.1'
+__version_tuple__ = version_tuple = (0, 15, 1)

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):

vispy/visuals/tests/test_gridlines.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+"""
+Tests for GridLines
+"""
+
+import numpy as np
+
+from vispy.scene import GridLines, STTransform
+from vispy.testing import (requires_application, TestingCanvas,
+                           run_tests_if_main)
+
+
+@requires_application()
+def test_gridlines():
+    with TestingCanvas(size=(80, 80)) as c:
+        grid = GridLines(parent=c.scene)
+        grid.transform = STTransform(translate=(40, 40))
+        render = c.render()
+        np.testing.assert_array_equal(render[40, 40], (151, 151, 151, 255))
+        np.testing.assert_array_equal(render[50, 50], (0, 0, 0, 255))
+
+        grid.grid_bounds = (-10, 10, -10, 10)
+        render = c.render()
+        np.testing.assert_array_equal(render[50, 50], (255, 255, 255, 255))
+
+
+run_tests_if_main()

vispy/visuals/tests/test_image.py

@@ -128,28 +128,30 @@ def test_image_clims_and_gamma(input_dtype, texture_format, num_channels,
 @pytest.mark.xfail(IS_CI, reason="CI environments sometimes treat NaN as 0")
 @requires_application()
 @pytest.mark.parametrize('texture_format', [None, 'auto'])
-def test_image_nan_single_band(texture_format):
-    size = (40, 40)
-    data = np.ones((40, 40))
-    data[:5, :5] = np.nan
-    data[:5, -5:] = 0
+@pytest.mark.parametrize('bad_color', [None, (1, 0, 0, 1)])
+def test_image_nan(texture_format, bad_color):
+    size = (80, 80)
+    data = np.ones(size)
+    data[:20, :20] = np.nan
+    data[-20: -20:] = 0
 
-    expected = (np.ones((40, 40, 4)) * 255).astype(np.uint8)
-    # black square
-    expected[:5, -5:, :3] = 0
+    expected = (np.ones(size + (4,)) * 255).astype(np.uint8)
+    expected[-20: -20:] = (0, 0, 0, 225)
     if texture_format is None:
         # CPU scaling's NaNs get converted to 0s
-        expected[:5, :5, :3] = 0
+        expected[:20, :20] = (0, 0, 0, 255)
     else:
         # GPU receives NaNs
-        # nan - transparent square
-        expected[:5, :5, 0] = 0
-        expected[:5, :5, 1] = 255  # match the 'green' background
-        expected[:5, :5, 2] = 0
+        # nan - mapped to bad color
+        if bad_color is None:
+            # no bad color means transparent, so we should see the green canvas
+            bad_color = (0, 1, 0, 1)
+        expected[:20, :20] = np.array(bad_color) * 255
 
     with TestingCanvas(size=size[::-1], bgcolor=(0, 1, 0)) as c:
-        Image(data, cmap='grays',
+        image = Image(data, cmap='grays', clim=(0, 1),
               texture_format=texture_format, parent=c.scene)
+        image.bad_color = bad_color
         rendered = c.render()
         np.testing.assert_allclose(rendered, expected)
 
@@ -327,7 +329,7 @@ def test_image_interpolation():
         assert np.allclose(render[center_left], black)
         assert np.allclose(render[center_right], white)
 
-        image.interpolation = 'bilinear'
+        image.interpolation = 'linear'
         render = c.render()
         assert np.allclose(render[left], black)
         assert np.allclose(render[right], white)

vispy/visuals/tests/test_scalable_textures.py

@@ -133,6 +133,22 @@ def test_clim_handling_cpu():
     assert st.clim == (5, 25)
     assert st.clim_normalized == (0, 1)
 
+    # u8 auto -> f32 auto
+    st = CPUScaledStub()
+    st.set_clim("auto")
+    assert st.clim == "auto"
+    st.scale_and_set_data(ref_data.astype(np.uint8))
+    assert st.clim == (5, 25)
+    assert st.clim_normalized == (0, 1)
+    # set new data with an out-of-range value
+    # it should clip at the limits of the original data type
+    st.set_clim("auto")
+    assert st.clim == "auto"
+    new_data = np.array([[10, 10, 5], [15, 2048, 15]], dtype=np.float32)
+    st.scale_and_set_data(new_data)
+    assert st.clim == (5, 255)
+    assert st.clim_normalized == (0, 1)
+
 
 def test_clim_handling_gpu():
     ref_data = np.array([[10, 10, 5], [15, 25, 15]])