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

vispy/visuals/mesh.py

@@ -283,8 +283,8 @@ class MeshVisual(Visual):
         clim_func = 'float cmap(float val) { return (val - $cmin) / ($cmax - $cmin); }'
         if colors.ndim == 2 and colors.shape[1] == 1:
             fun = Function(clim_func)
-            fun['cmin'] = self.clim[0]
-            fun['cmax'] = self.clim[1]
+            fun['cmin'] = self._clim_values[0]
+            fun['cmax'] = self._clim_values[1]
             fun = FunctionChain(None, [fun, Function(self.cmap.glsl_map)])
         else:
             fun = Function(null_color_transform)

vispy/visuals/shaders/function.py

@@ -309,6 +309,9 @@ class Function(ShaderObject):
         """
         return FunctionCall(self, args)
 
+    def __contains__(self, key):
+        return key in self.template_vars
+
     # Public API methods
 
     @property

vispy/visuals/shaders/tests/test_function.py

@@ -241,6 +241,12 @@ def test_function_basics():
     assert_equal(fun.name, 'main')
     assert len(fun.template_vars) == 2
     assert_in('foo', fun.template_vars)
+
+    # Test that `var in fun` syntax works as well
+    assert 'foo' in fun
+    assert 'bar' in fun
+    assert 'baz' not in fun
+
     assert_in('bar', fun.template_vars)
 
     # Test setting verbatim expressions

vispy/visuals/tests/test_axis.py

@@ -50,12 +50,12 @@ def test_rotation_angle():
     view.camera.elevation = 90.
 
     assert_allclose(axis1._rotation_angle, 0)
-    assert_allclose(axis2._rotation_angle, -30)
+    assert_allclose(axis2._rotation_angle, -30, rtol=1e-3)
 
     view.camera.elevation = 45.
 
     assert_allclose(axis1._rotation_angle, 0)
-    assert_allclose(axis2._rotation_angle, -22.207653)
+    assert_allclose(axis2._rotation_angle, -22.207653, rtol=1e-3)
 
     view.camera.fov = 20.
 

vispy/visuals/tests/test_image.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 from unittest import mock
 
-from vispy.scene.visuals import Image
+from vispy.scene import Image, PanZoomCamera
 from vispy.testing import (requires_application, TestingCanvas,
                            run_tests_if_main, IS_CI)
 from vispy.testing.image_tester import assert_image_approved, downsample
@@ -76,7 +76,7 @@ def _get_orig_and_new_clims(input_dtype):
 def test_image_clims_and_gamma(input_dtype, texture_format, num_channels,
                                clim_on_init, data_on_init):
     """Test image visual with clims and gamma on shader."""
-    size = (40, 40)
+    size = (80, 80)
     if texture_format == '__dtype__':
         texture_format = input_dtype
     shape = size + (num_channels,) if num_channels > 0 else size
@@ -297,4 +297,94 @@ def test_change_clim_float(dtype, init_clim):
         assert np.allclose(rendered1, rendered2)
 
 
+@requires_application()
+def test_image_interpolation():
+    """Test different interpolations"""
+    size = (81, 81)
+    data = np.array([[0, 1]], dtype=int)
+    left = (40, 0)
+    right = (40, 80)
+    center_left = (40, 39)
+    center = (40, 40)
+    center_right = (40, 41)
+    white = (255, 255, 255, 255)
+    black = (0, 0, 0, 255)
+    gray = (128, 128, 128, 255)
+
+    with TestingCanvas(size=size[::-1], bgcolor="w") as c:
+        view = c.central_widget.add_view(border_width=0)
+        view.camera = PanZoomCamera((0, 0, 2, 1))
+        image = Image(data=data, cmap='grays',
+                      parent=view.scene)
+
+        # needed to properly initialize the canvas
+        render = c.render()
+
+        image.interpolation = 'nearest'
+        render = c.render()
+        assert np.allclose(render[left], black)
+        assert np.allclose(render[right], white)
+        assert np.allclose(render[center_left], black)
+        assert np.allclose(render[center_right], white)
+
+        image.interpolation = 'bilinear'
+        render = c.render()
+        assert np.allclose(render[left], black)
+        assert np.allclose(render[right], white)
+        assert np.allclose(render[center], gray, atol=5)  # we just want gray, this is not quantitative
+
+        image.interpolation = 'custom'
+        image.custom_kernel = np.array([[0]])  # no sampling
+        render = c.render()
+        assert np.allclose(render[left], black)
+        assert np.allclose(render[right], black)
+        assert np.allclose(render[center], black)
+
+        image.custom_kernel = np.array([[1]])  # same as linear
+        render = c.render()
+        assert np.allclose(render[left], black)
+        assert np.allclose(render[right], white)
+        assert np.allclose(render[center], gray, atol=5)  # we just want gray, this is not quantitative
+
+
+@requires_application()
+def test_image_set_data_different_dtype():
+    size = (80, 80)
+    data = np.array([[0, 127]], dtype=np.int8)
+    left = (40, 10)
+    right = (40, 70)
+    white = (255, 255, 255, 255)
+    black = (0, 0, 0, 255)
+
+    with TestingCanvas(size=size[::-1], bgcolor="w") as c:
+        view = c.central_widget.add_view()
+        view.camera = PanZoomCamera((0, 0, 2, 1))
+        image = Image(data=data, cmap='grays', clim=[0, 127],
+                      parent=view.scene)
+
+        render = c.render()
+        assert np.allclose(render[left], black)
+        assert np.allclose(render[right], white)
+
+        # same data as float should change nothing
+        image.set_data(data.astype(np.float32))
+        render = c.render()
+        assert np.allclose(render[left], black)
+        assert np.allclose(render[right], white)
+
+        # something inverted, different dtype
+        new_data = np.array([[127, 0]], dtype=np.float16)
+        image.set_data(new_data)
+        render = c.render()
+        assert np.allclose(render[left], white)
+        assert np.allclose(render[right], black)
+
+        # out of bounds should clip (2000 > 127)
+        new_data = np.array([[0, 2000]], dtype=np.float64)
+        image.set_data(new_data)
+        render = c.render()
+        assert np.allclose(render[left], black)
+        assert np.allclose(render[right], white)
+
+
 run_tests_if_main()

vispy/visuals/tests/test_image_complex.py

@@ -0,0 +1,36 @@
+from vispy.scene.visuals import ComplexImage
+from vispy.visuals.image_complex import CPU_COMPLEX_TRANSFORMS
+from vispy.testing import requires_application, TestingCanvas
+from vispy.testing.image_tester import downsample
+
+import numpy as np
+import pytest
+
+from vispy.testing.rendered_array_tester import compare_render
+
+
+# we add the np.float32 case to test that ComplexImage falls back to Image behavior
+# if the data is not complex
+@requires_application()
+@pytest.mark.parametrize("input_dtype", [np.complex64, np.complex128, np.float32])
+@pytest.mark.parametrize("complex_mode", ["magnitude", "real", "imaginary", "phase"])
+def test_image_complex(input_dtype, complex_mode):
+    """Test rendering of complex-valued image data."""
+    shape = (40, 40)
+    np.random.seed(0)
+    data = np.random.random(shape).astype(input_dtype)
+    if np.iscomplexobj(data):
+        data.imag = np.random.random(shape)
+
+    with TestingCanvas(size=shape, bgcolor="w") as c:
+        ComplexImage(data, cmap="grays", complex_mode=complex_mode, parent=c.scene)
+        # render to canvas
+        rendered = c.render()
+        shape_ratio = rendered.shape[0] // data.shape[0]
+        rendered = downsample(rendered, shape_ratio, axis=(0, 1))
+
+        # perform (auto-clim) rendering on cpu
+        exp = CPU_COMPLEX_TRANSFORMS[complex_mode](data) if np.iscomplexobj(data) else data
+        exp -= exp.min()
+        exp /= exp.max()
+        compare_render(exp, rendered)

vispy/visuals/tests/test_instanced_mesh.py

@@ -0,0 +1,50 @@
+import numpy as np
+from vispy import scene, use
+
+from vispy.testing import (TestingCanvas, requires_application,
+                           run_tests_if_main, requires_pyopengl)
+
+
+def setup_module(module):
+    use(gl='gl+')
+
+
+def teardown_module(module):
+    use(gl='gl2')
+
+
+@requires_pyopengl()
+@requires_application()
+def test_mesh_with_vertex_values():
+    size = (80, 60)
+    with TestingCanvas(size=size) as c:
+        use(gl='gl+')
+        vert = np.array([[0, 0, 0], [0, 30, 0], [40, 0, 0]])
+        faces = np.array([0, 1, 2])
+        pos = np.array([[0, 0, 0], [80, 60, 0]])
+        # identity and rotate 180
+        trans = np.array([
+            [
+                [1, 0, 0],
+                [0, 1, 0],
+                [0, 0, 1],
+            ],
+            [
+                [-1, 0, 0],
+                [0, -1, 0],
+                [0, 0, 1],
+            ],
+        ])
+        colors = ['red', 'blue']
+        mesh = scene.visuals.InstancedMesh(
+            vertices=vert, faces=faces, instance_positions=pos, instance_transforms=trans, instance_colors=colors
+        )
+        v = c.central_widget.add_view(border_width=0)
+        v.add(mesh)
+        render = c.render()
+        assert np.allclose(render[10, 10], (255, 0, 0, 255))
+        assert np.allclose(render[-10, -10], (0, 0, 255, 255))
+        assert np.allclose(render[30, 40], (0, 0, 0, 255))
+
+
+run_tests_if_main()

vispy/visuals/tests/test_markers.py

@@ -45,4 +45,10 @@ def test_markers_edge_width():
     with pytest.raises(ValueError):
         marker.set_data(pos=data, edge_width_rel=edge_width - 1, edge_width=None)
 
+
+def test_empty_markers_symbol():
+    markers = Markers()
+    markers.symbol = 'o'
+
+
 run_tests_if_main()

vispy/visuals/tests/test_mesh.py

@@ -31,6 +31,23 @@ def test_mesh_color():
     np.testing.assert_allclose(vertices['position'], new_vertices)
 
 
+@requires_pyopengl()
+@requires_application()
+def test_mesh_with_vertex_values():
+    size = (45, 40)
+    with TestingCanvas(size=size) as c:
+        v = c.central_widget.add_view(border_width=0)
+        vertices = np.array([(0, 0, 0), (0, 0, 1), (1, 0, 0)], dtype=float)
+        faces = np.array([(0, 1, 2)])
+        mesh = scene.visuals.Mesh(
+            vertices=vertices,
+            faces=faces,
+            vertex_values=np.ones(len(vertices)),
+        )
+        v.add(mesh)
+        c.render()
+
+
 @requires_pyopengl()
 @requires_application()
 @pytest.mark.parametrize('shading', [None, 'flat', 'smooth'])

vispy/visuals/tests/test_text.py

@@ -81,4 +81,15 @@ def test_face_bold_italic():
         assert font1 is font4
 
 
+def test_text_depth_test():
+    t = Text(depth_test=False)
+    assert not t._vshare.gl_state["depth_test"]
+
+    t = Text(depth_test=True)
+    assert t._vshare.gl_state["depth_test"]
+
+    t = Text()  # Default is false
+    assert not t._vshare.gl_state["depth_test"]
+
+
 run_tests_if_main()

vispy/visuals/tests/test_volume.py

@@ -238,7 +238,7 @@ def _make_test_data(shape, input_dtype):
 @requires_pyopengl()
 def test_set_data_does_not_change_input():
     # Create volume
-    V = scene.visuals.Volume(np.zeros((20, 20, 20)))
+    V = scene.visuals.Volume(np.zeros((20, 20, 20), dtype=np.float32))
 
     # calling Volume.set_data() should NOT alter the values of the input array
     # regardless of data type
@@ -249,12 +249,36 @@ def test_set_data_does_not_change_input():
         V.set_data(vol_copy, clim=(0, 200))
         assert np.allclose(vol, vol_copy)
 
-    # for those using float32 who want to avoid the copy operation,
-    # using set_data() with `copy=False` should be expected to alter the data.
-    vol2 = np.array(vol, dtype='float32', copy=True)
+    # dtype has to be the same as the one used to init the texture, or it will
+    # be first coerced to the same dtype as the init
+
+    vol2 = np.array(vol, dtype=np.float32, copy=True)
     assert np.allclose(vol, vol2)
+    # we explicitly create a copy when data would be altered by the texture,
+    # no matter what the user asks, so the data outside should never change
     V.set_data(vol2, clim=(0, 200), copy=False)
-    assert not np.allclose(vol, vol2)
+    assert np.allclose(vol, vol2)
+
+
+@requires_pyopengl()
+def test_set_data_changes_shape():
+    dtype = np.float32
+    # Create initial volume
+    V = scene.visuals.Volume(np.zeros((20, 20, 20), dtype=dtype))
+
+    # Sending new three dimensional data of different shape should alter volume shape
+    vol = np.zeros((25, 25, 10), dtype=dtype)
+    V.set_data(vol)
+    assert V._vol_shape == (25, 25, 10)
+
+    # Sending data of dimension other than 3 should raise a ValueError
+    vol2 = np.zeros((20, 20), dtype=dtype)
+    with pytest.raises(ValueError):
+        V.set_data(vol2)
+
+    vol2 = np.zeros((20, 20, 20, 20), dtype=dtype)
+    with pytest.raises(ValueError):
+        V.set_data(vol2)
 
 
 @requires_pyopengl()
@@ -296,17 +320,17 @@ def test_changing_cmap():
 @requires_pyopengl()
 @requires_application()
 def test_plane_depth():
-    with TestingCanvas(size=(40, 40)) as c:
+    with TestingCanvas(size=(80, 80)) as c:
         v = c.central_widget.add_view(border_width=0)
         v.camera = 'arcball'
         v.camera.fov = 0
-        v.camera.center = (20, 20, 20)
-        v.camera.scale_factor = 40.0
+        v.camera.center = (40, 40, 40)
+        v.camera.scale_factor = 80.0
 
         # two planes at 45 degrees relative to the camera. If depth is set correctly, we should see one half
         # of the screen red and the other half white
         scene.visuals.Volume(
-            np.ones((40, 40, 40), dtype=np.uint8),
+            np.ones((80, 80, 80), dtype=np.uint8),
             interpolation="nearest",
             clim=(0, 1),
             cmap="grays",
@@ -316,7 +340,7 @@ def test_plane_depth():
         )
 
         scene.visuals.Volume(
-            np.ones((40, 40, 40), dtype=np.uint8),
+            np.ones((80, 80, 80), dtype=np.uint8),
             interpolation="nearest",
             clim=(0, 1),
             cmap="reds",
@@ -327,10 +351,192 @@ def test_plane_depth():
 
         # render with grays colormap
         rendered = c.render()
-        left = rendered[20, 10]
-        right = rendered[20, 30]
+        left = rendered[40, 20]
+        right = rendered[40, 60]
         assert np.array_equal(left, [255, 0, 0, 255])
         assert np.array_equal(right, [255, 255, 255, 255])
 
 
+@requires_pyopengl()
+@requires_application()
+def test_volume_depth():
+    """Check that depth setting is properly performed for the volume visual
+
+    Render a volume with a blue ball in front of a red plane in front of a
+    blue plane, checking that the output image contains both red and blue pixels.
+    """
+    # A blue strip behind a red strip
+    # If depth is set correctly, we should see only red pixels
+    # the screen
+    blue_vol = np.zeros((80, 80, 80), dtype=np.uint8)
+    blue_vol[:, -1, :] = 1  # back plane blue
+    blue_vol[30:50, 30:50, 30:50] = 1  # blue in center
+
+    red_vol = np.zeros((80, 80, 80), dtype=np.uint8)
+    red_vol[:, -5, :] = 1  # red plane in front of blue plane
+
+    with TestingCanvas(size=(80, 80)) as c:
+        v = c.central_widget.add_view(border_width=0)
+        v.camera = 'arcball'
+        v.camera.fov = 0
+        v.camera.center = (40, 40, 40)
+        v.camera.scale_factor = 80.0
+
+        scene.visuals.Volume(
+            red_vol,
+            interpolation="nearest",
+            clim=(0, 1),
+            cmap="reds",
+            parent=v.scene,
+        )
+
+        scene.visuals.Volume(
+            blue_vol,
+            interpolation="nearest",
+            clim=(0, 1),
+            cmap="blues",
+            parent=v.scene,
+        )
+
+        # render
+        rendered = c.render()
+        reds = np.sum(rendered[:, :, 0])
+        greens = np.sum(rendered[:, :, 1])
+        blues = np.sum(rendered[:, :, 2])
+        assert reds > 0
+        np.testing.assert_allclose(greens, 0)
+        assert blues > 0
+
+
+@requires_pyopengl()
+@requires_application()
+def test_mip_cutoff():
+    """
+    Ensure fragments are properly discarded based on the mip_cutoff
+    for the mip and attenuated_mip rendering methods
+    """
+    with TestingCanvas(size=(80, 80)) as c:
+        v = c.central_widget.add_view(border_width=0)
+        v.camera = 'arcball'
+        v.camera.fov = 0
+        v.camera.center = (40, 40, 40)
+        v.camera.scale_factor = 80.0
+
+        vol = scene.visuals.Volume(
+            np.ones((80, 80, 80), dtype=np.uint8),
+            interpolation="nearest",
+            clim=(0, 1),
+            cmap="grays",
+            parent=v.scene,
+        )
+
+        # we should see white
+        rendered = c.render()
+        assert np.array_equal(rendered[40, 40], [255, 255, 255, 255])
+
+        vol.mip_cutoff = 10
+        # we should see black
+        rendered = c.render()
+        assert np.array_equal(rendered[40, 40], [0, 0, 0, 255])
+
+        # repeat for attenuated_mip
+        vol.method = 'attenuated_mip'
+        vol.mip_cutoff = None
+
+        # we should see white
+        rendered = c.render()
+        assert np.array_equal(rendered[40, 40], [255, 255, 255, 255])
+
+        vol.mip_cutoff = 10
+        # we should see black
+        rendered = c.render()
+        assert np.array_equal(rendered[40, 40], [0, 0, 0, 255])
+
+
+@requires_pyopengl()
+@requires_application()
+def test_minip_cutoff():
+    """
+    Ensure fragments are properly discarded based on the minip_cutoff
+    for the minip rendering method
+    """
+    with TestingCanvas(size=(80, 80)) as c:
+        v = c.central_widget.add_view(border_width=0)
+        v.camera = 'arcball'
+        v.camera.fov = 0
+        v.camera.center = (40, 40, 40)
+        v.camera.scale_factor = 120.0
+
+        # just surface of the cube is ones, but it should win over the twos inside
+        data = np.ones((80, 80, 80), dtype=np.uint8)
+        data[1:-1, 1:-1, 1:-1] = 2
+
+        vol = scene.visuals.Volume(
+            data,
+            interpolation="nearest",
+            method='minip',
+            clim=(0, 2),
+            cmap="grays",
+            parent=v.scene,
+        )
+
+        # we should see gray (half of cmap)
+        rendered = c.render()
+        assert np.array_equal(rendered[40, 40], [128, 128, 128, 255])
+
+        # discard fragments above -10 (everything)
+        vol.minip_cutoff = -10
+        # we should see black
+        rendered = c.render()
+        assert np.array_equal(rendered[40, 40], [0, 0, 0, 255])
+
+
+@requires_pyopengl()
+@requires_application()
+def test_volume_set_data_different_dtype():
+    size = (80, 80)
+    data = np.array([[[0, 127]]], dtype=np.int8)
+    left = (40, 10)
+    right = (40, 70)
+    white = (255, 255, 255, 255)
+    black = (0, 0, 0, 255)
+
+    with TestingCanvas(size=size[::-1], bgcolor="w") as c:
+        view = c.central_widget.add_view()
+        view.camera = 'arcball'
+        view.camera.fov = 0
+        view.camera.center = 0.5, 0, 0
+        view.camera.scale_factor = 2
+        volume = scene.visuals.Volume(
+            data,
+            cmap='grays',
+            clim=[0, 127],
+            parent=view.scene
+        )
+
+        render = c.render()
+        assert np.allclose(render[left], black)
+        assert np.allclose(render[right], white)
+
+        # same data as float should change nothing
+        volume.set_data(data.astype(np.float32))
+        render = c.render()
+        assert np.allclose(render[left], black)
+        assert np.allclose(render[right], white)
+
+        # something inverted, different dtype
+        new_data = np.array([[[127, 0]]], dtype=np.float16)
+        volume.set_data(new_data)
+        render = c.render()
+        assert np.allclose(render[left], white)
+        assert np.allclose(render[right], black)
+
+        # out of bounds should clip (2000 > 127)
+        new_data = np.array([[[0, 2000]]], dtype=np.float64)
+        volume.set_data(new_data)
+        render = c.render()
+        assert np.allclose(render[left], black)
+        assert np.allclose(render[right], white)
+
+
 run_tests_if_main()

vispy/visuals/text/_sdf_cpu.pyx

@@ -1,5 +1,4 @@
-# -*- coding: utf-8 -*-
-
+# cython: language_level=3, boundscheck=False, cdivision=True, wraparound=False, initializedcheck=False, nonecheck=False
 # A Cython implementation of the "eight-points signed sequential Euclidean
 # distance transform algorithm" (8SSEDT)
 
@@ -18,13 +17,14 @@ ctypedef np.complex64_t DTYPE_ct
 cdef DTYPE_ct MAX_VAL = (1e6 + 1e6j)
 
 
-@cython.boundscheck(False)  # designed to stay within bounds
-@cython.wraparound(False)  # we don't use negative indexing
 def _calc_distance_field(np.ndarray[DTYPE_t, ndim=2] pixels,
                          int w, int h, DTYPE_t sp_f):
     # initialize grids
-    cdef np.ndarray[DTYPE_ct, ndim=2] g0 = np.zeros((h, w), dtype_c)
-    cdef np.ndarray[DTYPE_ct, ndim=2] g1 = np.zeros((h, w), dtype_c)
+    cdef np.ndarray[DTYPE_ct, ndim=2] g0_arr = np.zeros((h, w), dtype_c)
+    cdef np.ndarray[DTYPE_ct, ndim=2] g1_arr = np.zeros((h, w), dtype_c)
+    cdef DTYPE_ct[:, ::1] g0 = g0_arr
+    cdef DTYPE_ct[:, ::1] g1 = g1_arr
+    cdef DTYPE_t[:, :] pixels_view = pixels
     cdef Py_ssize_t y, x
     for y in range(h):
         g0[y, 0] = MAX_VAL
@@ -32,9 +32,9 @@ def _calc_distance_field(np.ndarray[DTYPE_t, ndim=2] pixels,
         g1[y, 0] = MAX_VAL
         g1[y, w-1] = MAX_VAL
         for x in range(1, w-1):
-            if pixels[y, x] > 0:
+            if pixels_view[y, x] > 0:
                 g0[y, x] = MAX_VAL
-            if pixels[y, x] < 1:
+            if pixels_view[y, x] < 1:
                 g1[y, x] = MAX_VAL
     for x in range(w):
         g0[0, x] = MAX_VAL
@@ -50,37 +50,35 @@ def _calc_distance_field(np.ndarray[DTYPE_t, ndim=2] pixels,
     cdef DTYPE_t r_sp_f_2 = 1. / (sp_f * 2.)
     for y in range(1, h-1):
         for x in range(1, w-1):
-            pixels[y, x] = sqrt(dist(g0[y, x])) - sqrt(dist(g1[y, x]))
-            if pixels[y, x] < 0:
-                pixels[y, x] = (pixels[y, x] + sp_f) * r_sp_f_2
+            pixels_view[y, x] = sqrt(dist(g0[y, x])) - sqrt(dist(g1[y, x]))
+            if pixels_view[y, x] < 0:
+                pixels_view[y, x] = (pixels_view[y, x] + sp_f) * r_sp_f_2
             else:
-                pixels[y, x] = 0.5 + pixels[y, x] * r_sp_f_2
-            pixels[y, x] = max(min(pixels[y, x], 1), 0)
+                pixels_view[y, x] = 0.5 + pixels_view[y, x] * r_sp_f_2
+            pixels_view[y, x] = max(min(pixels_view[y, x], 1), 0)
 
 
-@cython.boundscheck(False)  # designed to stay within bounds
-@cython.wraparound(False)  # we don't use negative indexing
-cdef Py_ssize_t compare(DTYPE_ct *cell, DTYPE_ct xy, DTYPE_t *current):
+cdef inline Py_ssize_t compare(DTYPE_ct *cell, DTYPE_ct xy, DTYPE_t *current) noexcept nogil:
     cdef DTYPE_t val = dist(xy)
     if val < current[0]:
         cell[0] = xy
         current[0] = val
 
 
-@cython.boundscheck(False)  # designed to stay within bounds
-@cython.wraparound(False)  # we don't use negative indexing
-cdef DTYPE_t dist(DTYPE_ct val):
+cdef DTYPE_t dist(DTYPE_ct val) noexcept nogil:
     return val.real*val.real + val.imag*val.imag
 
 
-@cython.boundscheck(False)  # designed to stay within bounds
-@cython.wraparound(False)  # we don't use negative indexing
-cdef void _propagate(np.ndarray[DTYPE_ct, ndim=2] grid):
+cdef void _propagate(DTYPE_ct[:, :] grid) noexcept nogil:
     cdef Py_ssize_t height = grid.shape[0]
     cdef Py_ssize_t width = grid.shape[1]
     cdef Py_ssize_t y, x
     cdef DTYPE_t current
-    cdef DTYPE_ct a0=-1, a1=-1j, a2=-1-1j, a3=1-1j
+    cdef DTYPE_ct a0, a1, a2, a3
+    a0 = -1
+    a1 = -1j
+    a2 = -1 - 1j
+    a3 = 1 - 1j
     cdef DTYPE_ct b0=1
     cdef DTYPE_ct c0=1, c1=1j, c2=-1+1j, c3=1+1j
     cdef DTYPE_ct d0=-1