Esempi in Python per doesnt_have_cuda

Esempio n. 1

    nir = create_test_arr(arr1)
    red = create_test_arr(arr2)
    numpy_result = ndvi(nir, red)

    # dask
    nir_dask = create_test_arr(arr1, backend='dask')
    red_dask = create_test_arr(arr2, backend='dask')

    test_result = ndvi(nir_dask, red_dask)
    assert isinstance(test_result.data, da.Array)

    test_result.data = test_result.data.compute()
    assert np.isclose(numpy_result, test_result, equal_nan=True).all()


@pytest.mark.skipif(doesnt_have_cuda(), reason="CUDA Device not Available")
def test_ndvi_cupy_equals_numpy():

    import cupy

    # vanilla numpy version
    nir = create_test_arr(arr1)
    red = create_test_arr(arr2)
    numpy_result = ndvi(nir, red)

    # cupy
    nir_cupy = create_test_arr(arr1, backend='cupy')
    red_cupy = create_test_arr(arr2, backend='cupy')
    test_result = ndvi(nir_cupy, red_cupy)

    assert isinstance(test_result.data, cupy.ndarray)

Esempio n. 2

File: test_multispectral.py Progetto: SapirLastimoza-Dooley/xarray-spatial

def test_gci_dask_equals_numpy():

def test_gci_dask_equals_numpy():
    # vanilla numpy version
    nir = create_test_arr(arr1)
    green = create_test_arr(arr2)
    numpy_result = gci(nir, green)

    # dask
    nir_dask = create_test_arr(arr1, backend='dask')
    green_dask = create_test_arr(arr2, backend='dask')
    test_result = gci(nir_dask, green_dask)

    assert isinstance(test_result.data, da.Array)
    test_result.data = test_result.data.compute()
    assert np.isclose(numpy_result, test_result, equal_nan=True).all()


@pytest.mark.skipif(doesnt_have_cuda(), reason="CUDA Dgcice not Available")
def test_gci_cupy_equals_numpy():

    import cupy

    # vanilla numpy version
    nir = create_test_arr(arr1)
    green = create_test_arr(arr2)
    numpy_result = gci(nir, green)

    # cupy
    nir_cupy = create_test_arr(arr1, backend='cupy')
    green_cupy = create_test_arr(arr2, backend='cupy')
    test_result = gci(nir_cupy, green_cupy)

    assert isinstance(test_result.data, cupy.ndarray)
    assert np.isclose(numpy_result, test_result, equal_nan=True).all()


@pytest.mark.skipif(doesnt_have_cuda(), reason="CUDA Dgcice not Available")
def test_gci_dask_cupy_equals_numpy():
    # vanilla numpy version
    nir = create_test_arr(arr1)
    green = create_test_arr(arr2)
    numpy_result = gci(nir, green)

    # dask + cupy
    nir_dask_cupy = create_test_arr(arr1, backend='dask+cupy')
    green_dask_cupy = create_test_arr(arr2, backend='dask+cupy')
    test_result = gci(nir_dask_cupy, green_dask_cupy)

    assert is_dask_cupy(test_result)

    test_result.data = test_result.data.compute()
    assert np.isclose(numpy_result, test_result, equal_nan=True).all()


# SIPI -------------
def test_sipi_numpy():
    nir = create_test_arr(arr1)

    # add crs for tests
    nir = _add_EPSG4326_crs_to_da(nir)

    red = create_test_arr(arr2)
    blue = create_test_arr(arr3)

    result = sipi(nir, red, blue)

    assert result.dims == nir.dims
    assert isinstance(result, xa.DataArray)
    assert result.dims == nir.dims

    # crs tests
    assert result.attrs == nir.attrs
    for coord in nir.coords:
        assert np.all(result[coord] == nir[coord])

def test_sipi_dask_equals_numpy():

    # vanilla numpy version
    nir = create_test_arr(arr1)
    red = create_test_arr(arr2)
    blue = create_test_arr(arr3)
    numpy_result = sipi(nir, red, blue)

    # dask
    nir_dask = create_test_arr(arr1, backend='dask')
    red_dask = create_test_arr(arr2, backend='dask')
    blue_dask = create_test_arr(arr3, backend='dask')
    test_result = sipi(nir_dask, red_dask, blue_dask)

    assert isinstance(test_result.data, da.Array)
    test_result.data = test_result.data.compute()
    assert np.isclose(numpy_result, test_result, equal_nan=True).all()


@pytest.mark.skipif(doesnt_have_cuda(), reason="CUDA Device not Available")
def test_sipi_cupy_equals_numpy():

    import cupy

    # vanilla numpy version
    nir = create_test_arr(arr1)
    red = create_test_arr(arr2)
    blue = create_test_arr(arr3)
    numpy_result = sipi(nir, red, blue)

    # cupy
    nir_dask = create_test_arr(arr1, backend='cupy')
    red_dask = create_test_arr(arr2, backend='cupy')
    blue_dask = create_test_arr(arr3, backend='cupy')
    test_result = sipi(nir_dask, red_dask, blue_dask)

    assert isinstance(test_result.data, cupy.ndarray)
    assert np.isclose(numpy_result, test_result, equal_nan=True).all()


@pytest.mark.skipif(doesnt_have_cuda(), reason="CUDA Device not Available")
def test_sipi_dask_cupy_equals_numpy():
    # vanilla numpy version
    nir = create_test_arr(arr1)
    red = create_test_arr(arr2)
    blue = create_test_arr(arr3)
    numpy_result = sipi(nir, red, blue)

    # dask + cupy
    nir_dask_cupy = create_test_arr(arr1, backend='dask+cupy')
    red_dask_cupy = create_test_arr(arr2, backend='dask+cupy')
    blue_dask_cupy = create_test_arr(arr3, backend='dask+cupy')
    test_result = sipi(nir_dask_cupy, red_dask_cupy, blue_dask_cupy)

    assert is_dask_cupy(test_result)
    test_result.data = test_result.data.compute()
    assert np.isclose(numpy_result, test_result, equal_nan=True).all()


# NBR -------------
def test_nbr_numpy():
    nir = create_test_arr(arr1)

    # add crs for tests
    nir = _add_EPSG4326_crs_to_da(nir)

    swir = create_test_arr(arr2)
    result = nbr(nir, swir)

    assert result.dims == nir.dims
    assert isinstance(result, xa.DataArray)
    assert result.dims == nir.dims

    # crs tests
    assert result.attrs == nir.attrs
    for coord in nir.coords:
        assert np.all(result[coord] == nir[coord])


def test_nbr_dask_equals_numpy():

    # vanilla numpy version
    nir = create_test_arr(arr1)
    swir = create_test_arr(arr2)
    numpy_result = nbr(nir, swir)

    # dask
    nir_dask = create_test_arr(arr1, backend='dask')
    swir_dask = create_test_arr(arr2, backend='dask')
    test_result = nbr(nir_dask, swir_dask)

    assert isinstance(test_result.data, da.Array)
    test_result.data = test_result.data.compute()
    assert np.isclose(numpy_result, test_result, equal_nan=True).all()


@pytest.mark.skipif(doesnt_have_cuda(), reason="CUDA Device not Available")
def test_nbr_cupy_equals_numpy():

    import cupy

    # vanilla numpy version
    nir = create_test_arr(arr1)
    swir = create_test_arr(arr2)
    numpy_result = nbr(nir, swir)

    # cupy
    nir_cupy = create_test_arr(arr1, backend='cupy')
    swir_cupy = create_test_arr(arr2, backend='cupy')
    test_result = nbr(nir_cupy, swir_cupy)

    assert isinstance(test_result.data, cupy.ndarray)
    assert np.isclose(numpy_result, test_result, equal_nan=True).all()


@pytest.mark.skipif(doesnt_have_cuda(), reason="CUDA Device not Available")
def test_nbr_dask_cupy_equals_numpy():
    # vanilla numpy version
    nir = create_test_arr(arr1)
    swir = create_test_arr(arr2)
    numpy_result = nbr(nir, swir)

    # dask + cupy
    nir_dask_cupy = create_test_arr(arr1, backend='dask+cupy')
    swir_dask_cupy = create_test_arr(arr2, backend='dask+cupy')
    test_result = nbr(nir_dask_cupy, swir_dask_cupy)

    assert is_dask_cupy(test_result)

    test_result.data = test_result.data.compute()
    assert np.isclose(numpy_result, test_result, equal_nan=True).all()


# NBR2 -------------
def test_nbr2_numpy():
    swir1 = create_test_arr(arr1)

    # add crs for tests
    swir1 = _add_EPSG4326_crs_to_da(swir1)

    swir2 = create_test_arr(arr2)

    result = nbr2(swir1, swir2)

    assert result.dims == swir1.dims
    assert isinstance(result, xa.DataArray)
    assert result.dims == swir1.dims

    # crs tests
    assert result.attrs == swir1.attrs
    for coord in swir1.coords:
        assert np.all(result[coord] == swir1[coord])

def test_nbr2_dask_equals_numpy():

    # vanilla numpy version
    swir1 = create_test_arr(arr1)
    swir2 = create_test_arr(arr2)
    numpy_result = nbr2(swir1, swir2)

    # dask
    swir1_dask = create_test_arr(arr1, backend='dask')
    swir2_dask = create_test_arr(arr2, backend='dask')
    test_result = nbr2(swir1_dask, swir2_dask)

    assert isinstance(test_result.data, da.Array)
    test_result.data = test_result.data.compute()
    assert np.isclose(numpy_result, test_result, equal_nan=True).all()


@pytest.mark.skipif(doesnt_have_cuda(), reason="CUDA Dnbr2ce not Available")
def test_nbr2_cupy_equals_numpy():

    import cupy

    # vanilla numpy version
    swir1 = create_test_arr(arr1)
    swir2 = create_test_arr(arr2)
    numpy_result = nbr2(swir1, swir2)

    # cupy
    swir1_cupy = create_test_arr(arr1, backend='cupy')
    swir2_cupy = create_test_arr(arr2, backend='cupy')
    test_result = nbr2(swir1_cupy, swir2_cupy)

    assert isinstance(test_result.data, cupy.ndarray)
    assert np.isclose(numpy_result, test_result, equal_nan=True).all()


@pytest.mark.skipif(doesnt_have_cuda(), reason="CUDA Dnbr2ce not Available")
def test_nbr2_dask_cupy_equals_numpy():
    # vanilla numpy version
    swir1 = create_test_arr(arr1)
    swir2 = create_test_arr(arr2)
    numpy_result = nbr2(swir1, swir2)

    # dask + cupy
    swir1_dask_cupy = create_test_arr(arr1, backend='dask+cupy')
    swir2_dask_cupy = create_test_arr(arr2, backend='dask+cupy')
    test_result = nbr2(swir1_dask_cupy, swir2_dask_cupy)

    assert is_dask_cupy(test_result)
    test_result.data = test_result.data.compute()
    assert np.isclose(numpy_result, test_result, equal_nan=True).all()


# NDMI -------------
def test_ndmi_numpy():
    nir = create_test_arr(arr1)

    # add crs for tests
    nir = _add_EPSG4326_crs_to_da(nir)

    swir1 = create_test_arr(arr2)

    result = ndmi(nir, swir1)

    assert result.dims == nir.dims
    assert isinstance(result, xa.DataArray)
    assert result.dims == nir.dims

    # crs tests
    assert result.attrs == nir.attrs
    for coord in nir.coords:
        assert np.all(result[coord] == nir[coord])


def test_ndmi_dask_equals_numpy():

    # vanilla numpy version
    nir = create_test_arr(arr1)
    swir1 = create_test_arr(arr2)
    numpy_result = ndmi(nir, swir1)

    # dask
    nir_dask = create_test_arr(arr1, backend='dask')
    swir1_dask = create_test_arr(arr2, backend='dask')
    test_result = ndmi(nir_dask, swir1_dask)

    assert isinstance(test_result.data, da.Array)
    test_result.data = test_result.data.compute()
    assert np.isclose(numpy_result, test_result, equal_nan=True).all()


@pytest.mark.skipif(doesnt_have_cuda(), reason="CUDA Device not Available")
def test_ndmi_cupy_equals_numpy():

    import cupy

    # vanilla numpy version
    nir = create_test_arr(arr1)
    swir1 = create_test_arr(arr2)
    numpy_result = ndmi(nir, swir1)

    # cupy
    nir_cupy = create_test_arr(arr1, backend='cupy')
    swir1_cupy = create_test_arr(arr2, backend='cupy')
    test_result = ndmi(nir_cupy, swir1_cupy)

    assert isinstance(test_result.data, cupy.ndarray)
    assert np.isclose(numpy_result, test_result, equal_nan=True).all()


@pytest.mark.skipif(doesnt_have_cuda(), reason="CUDA Device not Available")
def test_ndmi_dask_cupy_equals_numpy():
    # vanilla numpy version
    nir = create_test_arr(arr1)
    swir1 = create_test_arr(arr2)
    numpy_result = ndmi(nir, swir1)

    # dask + cupy
    nir_dask_cupy = create_test_arr(arr1, backend='dask+cupy')
    swir1_dask_cupy = create_test_arr(arr2, backend='dask+cupy')
    test_result = ndmi(nir_dask_cupy, swir1_dask_cupy)

    assert is_dask_cupy(test_result)
    test_result.data = test_result.data.compute()
    assert np.isclose(numpy_result, test_result, equal_nan=True).all()


# EBBI -------------
def test_ebbi_numpy():
    red = create_test_arr(arr1)

    # add crs for tests
    red = _add_EPSG4326_crs_to_da(red)

    swir = create_test_arr(arr2)
    tir = create_test_arr(arr3)
    numpy_result = ebbi(red, swir, tir)

    assert numpy_result.dims == red.dims
    assert isinstance(numpy_result, xa.DataArray)
    assert numpy_result.dims == red.dims

    # crs tests
    assert numpy_result.attrs == red.attrs
    for coord in red.coords:
        assert np.all(numpy_result[coord] == red[coord])

def test_ebbi_dask_equals_numpy():

    # vanilla numpy version
    red = create_test_arr(arr1)
    swir = create_test_arr(arr2)
    tir = create_test_arr(arr3)
    numpy_result = ebbi(red, swir, tir)

    # dask
    red_dask = create_test_arr(arr1, backend='dask')
    swir_dask = create_test_arr(arr2, backend='dask')
    tir_dask = create_test_arr(arr3, backend='dask')
    test_result = ebbi(red_dask, swir_dask, tir_dask)

    assert isinstance(test_result.data, da.Array)
    test_result.data = test_result.data.compute()
    assert np.isclose(numpy_result, test_result, equal_nan=True).all()


@pytest.mark.skipif(doesnt_have_cuda(), reason="CUDA Device not Available")
def test_ebbi_cupy_equals_numpy():

    import cupy

    # vanilla numpy version
    red = create_test_arr(arr1)
    swir = create_test_arr(arr2)
    tir = create_test_arr(arr3)
    numpy_result = ebbi(red, swir, tir)

    # cupy
    red_dask = create_test_arr(arr1, backend='cupy')
    swir_dask = create_test_arr(arr2, backend='cupy')
    tir_dask = create_test_arr(arr3, backend='cupy')
    test_result = ebbi(red_dask, swir_dask, tir_dask)

    assert isinstance(test_result.data, cupy.ndarray)
    assert np.isclose(numpy_result, test_result, equal_nan=True).all()


@pytest.mark.skipif(doesnt_have_cuda(), reason="CUDA Device not Available")
def test_ebbi_dask_cupy_equals_numpy():
    # vanilla numpy version
    red = create_test_arr(arr1)
    swir = create_test_arr(arr2)
    tir = create_test_arr(arr3)
    numpy_result = ebbi(red, swir, tir)

    # dask + cupy
    red_dask_cupy = create_test_arr(arr1, backend='dask+cupy')
    swir_dask_cupy = create_test_arr(arr2, backend='dask+cupy')
    tir_dask_cupy = create_test_arr(arr3, backend='dask+cupy')
    test_result = ebbi(red_dask_cupy, swir_dask_cupy, tir_dask_cupy)

    assert is_dask_cupy(test_result)
    test_result.data = test_result.data.compute()
    assert np.isclose(numpy_result, test_result, equal_nan=True).all()


def test_true_color_cpu():
    # vanilla numpy version
    red = create_test_arr(arr1)
    green = create_test_arr(arr2)
    blue = create_test_arr(arr3)
    numpy_result = true_color(red, green, blue)

    # dask
    red_dask = create_test_arr(arr1, backend='dask')
    green_dask = create_test_arr(arr2, backend='dask')
    blue_dask = create_test_arr(arr3, backend='dask')
    dask_result = true_color(red_dask, green_dask, blue_dask)

    # TODO: test output metadata: dims, coords, attrs
    assert isinstance(numpy_result, xa.DataArray)
    assert isinstance(dask_result.data, da.Array)
    dask_result.data = dask_result.data.compute()
    assert np.isclose(numpy_result, dask_result, equal_nan=True).all()