FAILED [ 20%]
test_basic_features.py:39 (test_multiscale_basic_features_channel_axis[0])
channel_axis = 0

    @pytest.mark.parametrize('channel_axis', [0, 1, 2, -1, -2])
    def test_multiscale_basic_features_channel_axis(channel_axis):
        num_channels = 5
        shape_spatial = (10, 10)
        ndim = len(shape_spatial)
        shape = tuple(
            np.insert(shape_spatial, channel_axis % (ndim + 1), num_channels)
        )
        img = np.zeros(shape)
        img[:10] = 1
        img += 0.05 * np.random.randn(*img.shape)
        n_sigmas = 2
    
        # features for all channels are concatenated along the last axis
        features = multiscale_basic_features(img, sigma_min=1, sigma_max=2,
                                             channel_axis=channel_axis)
        assert features.shape[-1] == 5 * n_sigmas * 4
        assert features.shape[:-1] == np.moveaxis(img, channel_axis, -1).shape[:-1]
    
        # Consider channel_axis as spatial dimension
>       features = multiscale_basic_features(img, sigma_min=1, sigma_max=2)

test_basic_features.py:60: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../_basic_features.py:180: in multiscale_basic_features
    features = list(itertools.chain.from_iterable(all_results))
../_basic_features.py:168: in <genexpr>
    _mutiscale_basic_features_singlechannel(
../_basic_features.py:87: in _mutiscale_basic_features_singlechannel
    out_sigmas = list(
/usr/lib/python3.11/concurrent/futures/_base.py:619: in result_iterator
    yield _result_or_cancel(fs.pop())
/usr/lib/python3.11/concurrent/futures/_base.py:317: in _result_or_cancel
    return fut.result(timeout)
/usr/lib/python3.11/concurrent/futures/_base.py:449: in result
    return self.__get_result()
/usr/lib/python3.11/concurrent/futures/_base.py:401: in __get_result
    raise self._exception
/usr/lib/python3.11/concurrent/futures/thread.py:58: in run
    result = self.fn(*self.args, **self.kwargs)
../_basic_features.py:89: in <lambda>
    lambda s: _singlescale_basic_features_singlechannel(
../_basic_features.py:28: in _singlescale_basic_features_singlechannel
    results += (*_texture_filter(gaussian_filtered),)
../_basic_features.py:14: in _texture_filter
    eigvals = feature.hessian_matrix_eigvals(H_elems)
../corner.py:510: in hessian_matrix_eigvals
    return _symmetric_compute_eigenvalues(H_elems)
../corner.py:412: in _symmetric_compute_eigenvalues
    eigs = np.linalg.eigvalsh(matrices)[..., ::-1]
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

a = array([[[[[-1.76429749e-05, -3.95774841e-05, -8.44955444e-04],
          [-3.95774841e-05, -6.33984804e-04,  1.6325712...00112772e-04,  2.67672539e-03],
          [ 9.18269157e-04,  2.67672539e-03,  0.00000000e+00]]]]],
      dtype=float32)
UPLO = 'L'

    @array_function_dispatch(_eigvalsh_dispatcher)
    def eigvalsh(a, UPLO='L'):
        """
        Compute the eigenvalues of a complex Hermitian or real symmetric matrix.
    
        Main difference from eigh: the eigenvectors are not computed.
    
        Parameters
        ----------
        a : (..., M, M) array_like
            A complex- or real-valued matrix whose eigenvalues are to be
            computed.
        UPLO : {'L', 'U'}, optional
            Specifies whether the calculation is done with the lower triangular
            part of `a` ('L', default) or the upper triangular part ('U').
            Irrespective of this value only the real parts of the diagonal will
            be considered in the computation to preserve the notion of a Hermitian
            matrix. It therefore follows that the imaginary part of the diagonal
            will always be treated as zero.
    
        Returns
        -------
        w : (..., M,) ndarray
            The eigenvalues in ascending order, each repeated according to
            its multiplicity.
    
        Raises
        ------
        LinAlgError
            If the eigenvalue computation does not converge.
    
        See Also
        --------
        eigh : eigenvalues and eigenvectors of real symmetric or complex Hermitian
               (conjugate symmetric) arrays.
        eigvals : eigenvalues of general real or complex arrays.
        eig : eigenvalues and right eigenvectors of general real or complex
              arrays.
        scipy.linalg.eigvalsh : Similar function in SciPy.
    
        Notes
        -----
    
        .. versionadded:: 1.8.0
    
        Broadcasting rules apply, see the `numpy.linalg` documentation for
        details.
    
        The eigenvalues are computed using LAPACK routines ``_syevd``, ``_heevd``.
    
        Examples
        --------
        >>> from numpy import linalg as LA
        >>> a = np.array([[1, -2j], [2j, 5]])
        >>> LA.eigvalsh(a)
        array([ 0.17157288,  5.82842712]) # may vary
    
        >>> # demonstrate the treatment of the imaginary part of the diagonal
        >>> a = np.array([[5+2j, 9-2j], [0+2j, 2-1j]])
        >>> a
        array([[5.+2.j, 9.-2.j],
               [0.+2.j, 2.-1.j]])
        >>> # with UPLO='L' this is numerically equivalent to using LA.eigvals()
        >>> # with:
        >>> b = np.array([[5.+0.j, 0.-2.j], [0.+2.j, 2.-0.j]])
        >>> b
        array([[5.+0.j, 0.-2.j],
               [0.+2.j, 2.+0.j]])
        >>> wa = LA.eigvalsh(a)
        >>> wb = LA.eigvals(b)
        >>> wa; wb
        array([1., 6.])
        array([6.+0.j, 1.+0.j])
    
        """
        UPLO = UPLO.upper()
        if UPLO not in ('L', 'U'):
            raise ValueError("UPLO argument must be 'L' or 'U'")
    
        extobj = get_linalg_error_extobj(
            _raise_linalgerror_eigenvalues_nonconvergence)
        if UPLO == 'L':
            gufunc = _umath_linalg.eigvalsh_lo
        else:
            gufunc = _umath_linalg.eigvalsh_up
    
        a, wrap = _makearray(a)
        _assert_stacked_2d(a)
        _assert_stacked_square(a)
        t, result_t = _commonType(a)
        signature = 'D->d' if isComplexType(t) else 'd->d'
>       w = gufunc(a, signature=signature, extobj=extobj)
E       ValueError: On entry to DSYEVD parameter number 8 had an illegal value

/home/lg/.local/lib/venv/skimagedev/lib/python3.11/site-packages/numpy/linalg/linalg.py:1181: ValueError