Static code analysis and corrections
This commit is contained in:
Kristjan Komlosi
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
@@ -0,0 +1,4 @@
|
||||
label_inputs.txt, label_strels.txt, and label_results.txt are test
|
||||
vectors generated using ndimage.label from scipy version 0.10.0, and
|
||||
are used to verify that the cython version behaves as expected. The
|
||||
script to generate them is in ../../utils/generate_label_testvectors.py
|
||||
@@ -0,0 +1,21 @@
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 0 1 1 1
|
||||
1 1 0 0 0 1 1
|
||||
1 0 1 0 1 0 1
|
||||
0 0 0 1 0 0 0
|
||||
1 0 1 0 1 0 1
|
||||
1 1 0 0 0 1 1
|
||||
1 1 1 0 1 1 1
|
||||
1 0 1 1 1 0 1
|
||||
0 0 0 1 0 0 0
|
||||
1 0 0 1 0 0 1
|
||||
1 1 1 1 1 1 1
|
||||
1 0 0 1 0 0 1
|
||||
0 0 0 1 0 0 0
|
||||
1 0 1 1 1 0 1
|
||||
@@ -0,0 +1,294 @@
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
2 2 2 2 2 2 2
|
||||
3 3 3 3 3 3 3
|
||||
4 4 4 4 4 4 4
|
||||
5 5 5 5 5 5 5
|
||||
6 6 6 6 6 6 6
|
||||
7 7 7 7 7 7 7
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 2 3 4 5 6 7
|
||||
8 9 10 11 12 13 14
|
||||
15 16 17 18 19 20 21
|
||||
22 23 24 25 26 27 28
|
||||
29 30 31 32 33 34 35
|
||||
36 37 38 39 40 41 42
|
||||
43 44 45 46 47 48 49
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 2 3 4 5 6 7
|
||||
8 1 2 3 4 5 6
|
||||
9 8 1 2 3 4 5
|
||||
10 9 8 1 2 3 4
|
||||
11 10 9 8 1 2 3
|
||||
12 11 10 9 8 1 2
|
||||
13 12 11 10 9 8 1
|
||||
1 2 3 4 5 6 7
|
||||
1 2 3 4 5 6 7
|
||||
1 2 3 4 5 6 7
|
||||
1 2 3 4 5 6 7
|
||||
1 2 3 4 5 6 7
|
||||
1 2 3 4 5 6 7
|
||||
1 2 3 4 5 6 7
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 2 1 2 1 2 1
|
||||
2 1 2 1 2 1 2
|
||||
1 2 1 2 1 2 1
|
||||
2 1 2 1 2 1 2
|
||||
1 2 1 2 1 2 1
|
||||
2 1 2 1 2 1 2
|
||||
1 2 1 2 1 2 1
|
||||
1 2 3 4 5 6 7
|
||||
2 3 4 5 6 7 8
|
||||
3 4 5 6 7 8 9
|
||||
4 5 6 7 8 9 10
|
||||
5 6 7 8 9 10 11
|
||||
6 7 8 9 10 11 12
|
||||
7 8 9 10 11 12 13
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 1 1 1 1
|
||||
1 1 1 0 2 2 2
|
||||
1 1 0 0 0 2 2
|
||||
1 0 3 0 2 0 4
|
||||
0 0 0 2 0 0 0
|
||||
5 0 2 0 6 0 7
|
||||
2 2 0 0 0 7 7
|
||||
2 2 2 0 7 7 7
|
||||
1 1 1 0 2 2 2
|
||||
1 1 0 0 0 2 2
|
||||
3 0 1 0 4 0 2
|
||||
0 0 0 1 0 0 0
|
||||
5 0 6 0 1 0 7
|
||||
5 5 0 0 0 1 1
|
||||
5 5 5 0 1 1 1
|
||||
1 1 1 0 2 2 2
|
||||
3 3 0 0 0 4 4
|
||||
5 0 6 0 7 0 8
|
||||
0 0 0 9 0 0 0
|
||||
10 0 11 0 12 0 13
|
||||
14 14 0 0 0 15 15
|
||||
16 16 16 0 17 17 17
|
||||
1 1 1 0 2 3 3
|
||||
1 1 0 0 0 3 3
|
||||
1 0 4 0 3 0 3
|
||||
0 0 0 3 0 0 0
|
||||
3 0 3 0 5 0 6
|
||||
3 3 0 0 0 6 6
|
||||
3 3 7 0 6 6 6
|
||||
1 2 3 0 4 5 6
|
||||
7 8 0 0 0 9 10
|
||||
11 0 12 0 13 0 14
|
||||
0 0 0 15 0 0 0
|
||||
16 0 17 0 18 0 19
|
||||
20 21 0 0 0 22 23
|
||||
24 25 26 0 27 28 29
|
||||
1 1 1 0 2 2 2
|
||||
1 1 0 0 0 2 2
|
||||
1 0 3 0 2 0 2
|
||||
0 0 0 2 0 0 0
|
||||
2 0 2 0 4 0 5
|
||||
2 2 0 0 0 5 5
|
||||
2 2 2 0 5 5 5
|
||||
1 1 1 0 2 2 2
|
||||
1 1 0 0 0 2 2
|
||||
1 0 3 0 4 0 2
|
||||
0 0 0 5 0 0 0
|
||||
6 0 7 0 8 0 9
|
||||
6 6 0 0 0 9 9
|
||||
6 6 6 0 9 9 9
|
||||
1 2 3 0 4 5 6
|
||||
7 1 0 0 0 4 5
|
||||
8 0 1 0 9 0 4
|
||||
0 0 0 1 0 0 0
|
||||
10 0 11 0 1 0 12
|
||||
13 10 0 0 0 1 14
|
||||
15 13 10 0 16 17 1
|
||||
1 2 3 0 4 5 6
|
||||
1 2 0 0 0 5 6
|
||||
1 0 7 0 8 0 6
|
||||
0 0 0 9 0 0 0
|
||||
10 0 11 0 12 0 13
|
||||
10 14 0 0 0 15 13
|
||||
10 14 16 0 17 15 13
|
||||
1 1 1 0 1 1 1
|
||||
1 1 0 0 0 1 1
|
||||
1 0 1 0 1 0 1
|
||||
0 0 0 1 0 0 0
|
||||
1 0 1 0 1 0 1
|
||||
1 1 0 0 0 1 1
|
||||
1 1 1 0 1 1 1
|
||||
1 1 2 0 3 3 3
|
||||
1 1 0 0 0 3 3
|
||||
1 0 1 0 4 0 3
|
||||
0 0 0 1 0 0 0
|
||||
5 0 6 0 1 0 1
|
||||
5 5 0 0 0 1 1
|
||||
5 5 5 0 7 1 1
|
||||
1 2 1 0 1 3 1
|
||||
2 1 0 0 0 1 3
|
||||
1 0 1 0 1 0 1
|
||||
0 0 0 1 0 0 0
|
||||
1 0 1 0 1 0 1
|
||||
4 1 0 0 0 1 5
|
||||
1 4 1 0 1 5 1
|
||||
1 2 3 0 4 5 6
|
||||
2 3 0 0 0 6 7
|
||||
3 0 8 0 6 0 9
|
||||
0 0 0 6 0 0 0
|
||||
10 0 6 0 11 0 12
|
||||
13 6 0 0 0 12 14
|
||||
6 15 16 0 12 14 17
|
||||
1 1 1 0 2 2 2
|
||||
1 1 0 0 0 2 2
|
||||
1 0 1 0 3 0 2
|
||||
0 0 0 1 0 0 0
|
||||
4 0 5 0 1 0 1
|
||||
4 4 0 0 0 1 1
|
||||
4 4 4 0 1 1 1
|
||||
1 0 2 2 2 0 3
|
||||
0 0 0 2 0 0 0
|
||||
4 0 0 5 0 0 5
|
||||
5 5 5 5 5 5 5
|
||||
5 0 0 5 0 0 6
|
||||
0 0 0 7 0 0 0
|
||||
8 0 7 7 7 0 9
|
||||
1 0 2 2 2 0 3
|
||||
0 0 0 2 0 0 0
|
||||
4 0 0 4 0 0 5
|
||||
4 4 4 4 4 4 4
|
||||
6 0 0 4 0 0 4
|
||||
0 0 0 7 0 0 0
|
||||
8 0 7 7 7 0 9
|
||||
1 0 2 2 2 0 3
|
||||
0 0 0 4 0 0 0
|
||||
5 0 0 6 0 0 7
|
||||
8 8 8 8 8 8 8
|
||||
9 0 0 10 0 0 11
|
||||
0 0 0 12 0 0 0
|
||||
13 0 14 14 14 0 15
|
||||
1 0 2 3 3 0 4
|
||||
0 0 0 3 0 0 0
|
||||
5 0 0 3 0 0 6
|
||||
5 5 3 3 3 6 6
|
||||
5 0 0 3 0 0 6
|
||||
0 0 0 3 0 0 0
|
||||
7 0 3 3 8 0 9
|
||||
1 0 2 3 4 0 5
|
||||
0 0 0 6 0 0 0
|
||||
7 0 0 8 0 0 9
|
||||
10 11 12 13 14 15 16
|
||||
17 0 0 18 0 0 19
|
||||
0 0 0 20 0 0 0
|
||||
21 0 22 23 24 0 25
|
||||
1 0 2 2 2 0 3
|
||||
0 0 0 2 0 0 0
|
||||
2 0 0 2 0 0 2
|
||||
2 2 2 2 2 2 2
|
||||
2 0 0 2 0 0 2
|
||||
0 0 0 2 0 0 0
|
||||
4 0 2 2 2 0 5
|
||||
1 0 2 2 2 0 3
|
||||
0 0 0 2 0 0 0
|
||||
2 0 0 2 0 0 2
|
||||
2 2 2 2 2 2 2
|
||||
2 0 0 2 0 0 2
|
||||
0 0 0 2 0 0 0
|
||||
4 0 2 2 2 0 5
|
||||
1 0 2 3 4 0 5
|
||||
0 0 0 2 0 0 0
|
||||
6 0 0 7 0 0 8
|
||||
9 6 10 11 7 12 13
|
||||
14 0 0 10 0 0 12
|
||||
0 0 0 15 0 0 0
|
||||
16 0 17 18 15 0 19
|
||||
1 0 2 3 4 0 5
|
||||
0 0 0 3 0 0 0
|
||||
6 0 0 3 0 0 7
|
||||
6 8 9 3 10 11 7
|
||||
6 0 0 3 0 0 7
|
||||
0 0 0 3 0 0 0
|
||||
12 0 13 3 14 0 15
|
||||
1 0 2 2 2 0 3
|
||||
0 0 0 2 0 0 0
|
||||
2 0 0 2 0 0 2
|
||||
2 2 2 2 2 2 2
|
||||
2 0 0 2 0 0 2
|
||||
0 0 0 2 0 0 0
|
||||
4 0 2 2 2 0 5
|
||||
1 0 2 2 3 0 4
|
||||
0 0 0 2 0 0 0
|
||||
5 0 0 2 0 0 6
|
||||
5 5 2 2 2 6 6
|
||||
5 0 0 2 0 0 6
|
||||
0 0 0 2 0 0 0
|
||||
7 0 8 2 2 0 9
|
||||
1 0 2 3 2 0 4
|
||||
0 0 0 2 0 0 0
|
||||
5 0 0 6 0 0 7
|
||||
8 5 6 9 6 7 10
|
||||
5 0 0 6 0 0 7
|
||||
0 0 0 11 0 0 0
|
||||
12 0 11 13 11 0 14
|
||||
1 0 2 3 4 0 5
|
||||
0 0 0 4 0 0 0
|
||||
6 0 0 7 0 0 8
|
||||
9 10 7 11 12 8 13
|
||||
10 0 0 12 0 0 14
|
||||
0 0 0 15 0 0 0
|
||||
16 0 15 17 18 0 19
|
||||
1 0 2 2 2 0 3
|
||||
0 0 0 2 0 0 0
|
||||
2 0 0 2 0 0 2
|
||||
2 2 2 2 2 2 2
|
||||
2 0 0 2 0 0 2
|
||||
0 0 0 2 0 0 0
|
||||
4 0 2 2 2 0 5
|
||||
@@ -0,0 +1,42 @@
|
||||
0 0 1
|
||||
1 1 1
|
||||
1 0 0
|
||||
1 0 0
|
||||
1 1 1
|
||||
0 0 1
|
||||
0 0 0
|
||||
1 1 1
|
||||
0 0 0
|
||||
0 1 1
|
||||
0 1 0
|
||||
1 1 0
|
||||
0 0 0
|
||||
0 0 0
|
||||
0 0 0
|
||||
0 1 1
|
||||
1 1 1
|
||||
1 1 0
|
||||
0 1 0
|
||||
1 1 1
|
||||
0 1 0
|
||||
1 0 0
|
||||
0 1 0
|
||||
0 0 1
|
||||
0 1 0
|
||||
0 1 0
|
||||
0 1 0
|
||||
1 1 1
|
||||
1 1 1
|
||||
1 1 1
|
||||
1 1 0
|
||||
0 1 0
|
||||
0 1 1
|
||||
1 0 1
|
||||
0 1 0
|
||||
1 0 1
|
||||
0 0 1
|
||||
0 1 0
|
||||
1 0 0
|
||||
1 1 0
|
||||
1 1 1
|
||||
0 1 1
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 2.1 KiB |
@@ -0,0 +1,100 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import assert_allclose
|
||||
|
||||
from scipy import ndimage
|
||||
from scipy.ndimage import _ctest
|
||||
from scipy.ndimage import _ctest_oldapi
|
||||
from scipy.ndimage import _cytest
|
||||
from scipy._lib._ccallback import LowLevelCallable
|
||||
|
||||
FILTER1D_FUNCTIONS = [
|
||||
lambda filter_size: _ctest.filter1d(filter_size),
|
||||
lambda filter_size: _ctest_oldapi.filter1d(filter_size),
|
||||
lambda filter_size: _cytest.filter1d(filter_size, with_signature=False),
|
||||
lambda filter_size: LowLevelCallable(_cytest.filter1d(filter_size, with_signature=True)),
|
||||
lambda filter_size: LowLevelCallable.from_cython(_cytest, "_filter1d",
|
||||
_cytest.filter1d_capsule(filter_size)),
|
||||
]
|
||||
|
||||
FILTER2D_FUNCTIONS = [
|
||||
lambda weights: _ctest.filter2d(weights),
|
||||
lambda weights: _ctest_oldapi.filter2d(weights),
|
||||
lambda weights: _cytest.filter2d(weights, with_signature=False),
|
||||
lambda weights: LowLevelCallable(_cytest.filter2d(weights, with_signature=True)),
|
||||
lambda weights: LowLevelCallable.from_cython(_cytest, "_filter2d", _cytest.filter2d_capsule(weights)),
|
||||
]
|
||||
|
||||
TRANSFORM_FUNCTIONS = [
|
||||
lambda shift: _ctest.transform(shift),
|
||||
lambda shift: _ctest_oldapi.transform(shift),
|
||||
lambda shift: _cytest.transform(shift, with_signature=False),
|
||||
lambda shift: LowLevelCallable(_cytest.transform(shift, with_signature=True)),
|
||||
lambda shift: LowLevelCallable.from_cython(_cytest, "_transform", _cytest.transform_capsule(shift)),
|
||||
]
|
||||
|
||||
|
||||
def test_generic_filter():
|
||||
def filter2d(footprint_elements, weights):
|
||||
return (weights*footprint_elements).sum()
|
||||
|
||||
def check(j):
|
||||
func = FILTER2D_FUNCTIONS[j]
|
||||
|
||||
im = np.ones((20, 20))
|
||||
im[:10,:10] = 0
|
||||
footprint = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]])
|
||||
footprint_size = np.count_nonzero(footprint)
|
||||
weights = np.ones(footprint_size)/footprint_size
|
||||
|
||||
res = ndimage.generic_filter(im, func(weights),
|
||||
footprint=footprint)
|
||||
std = ndimage.generic_filter(im, filter2d, footprint=footprint,
|
||||
extra_arguments=(weights,))
|
||||
assert_allclose(res, std, err_msg="#{} failed".format(j))
|
||||
|
||||
for j, func in enumerate(FILTER2D_FUNCTIONS):
|
||||
check(j)
|
||||
|
||||
|
||||
def test_generic_filter1d():
|
||||
def filter1d(input_line, output_line, filter_size):
|
||||
for i in range(output_line.size):
|
||||
output_line[i] = 0
|
||||
for j in range(filter_size):
|
||||
output_line[i] += input_line[i+j]
|
||||
output_line /= filter_size
|
||||
|
||||
def check(j):
|
||||
func = FILTER1D_FUNCTIONS[j]
|
||||
|
||||
im = np.tile(np.hstack((np.zeros(10), np.ones(10))), (10, 1))
|
||||
filter_size = 3
|
||||
|
||||
res = ndimage.generic_filter1d(im, func(filter_size),
|
||||
filter_size)
|
||||
std = ndimage.generic_filter1d(im, filter1d, filter_size,
|
||||
extra_arguments=(filter_size,))
|
||||
assert_allclose(res, std, err_msg="#{} failed".format(j))
|
||||
|
||||
for j, func in enumerate(FILTER1D_FUNCTIONS):
|
||||
check(j)
|
||||
|
||||
|
||||
def test_geometric_transform():
|
||||
def transform(output_coordinates, shift):
|
||||
return output_coordinates[0] - shift, output_coordinates[1] - shift
|
||||
|
||||
def check(j):
|
||||
func = TRANSFORM_FUNCTIONS[j]
|
||||
|
||||
im = np.arange(12).reshape(4, 3).astype(np.float64)
|
||||
shift = 0.5
|
||||
|
||||
res = ndimage.geometric_transform(im, func(shift))
|
||||
std = ndimage.geometric_transform(im, transform, extra_arguments=(shift,))
|
||||
assert_allclose(res, std, err_msg="#{} failed".format(j))
|
||||
|
||||
for j, func in enumerate(TRANSFORM_FUNCTIONS):
|
||||
check(j)
|
||||
@@ -0,0 +1,68 @@
|
||||
""" Testing data types for ndimage calls
|
||||
"""
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import sys
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import assert_array_almost_equal, assert_
|
||||
import pytest
|
||||
|
||||
from scipy import ndimage
|
||||
|
||||
|
||||
def test_map_coordinates_dts():
|
||||
# check that ndimage accepts different data types for interpolation
|
||||
data = np.array([[4, 1, 3, 2],
|
||||
[7, 6, 8, 5],
|
||||
[3, 5, 3, 6]])
|
||||
shifted_data = np.array([[0, 0, 0, 0],
|
||||
[0, 4, 1, 3],
|
||||
[0, 7, 6, 8]])
|
||||
idx = np.indices(data.shape)
|
||||
dts = (np.uint8, np.uint16, np.uint32, np.uint64,
|
||||
np.int8, np.int16, np.int32, np.int64,
|
||||
np.intp, np.uintp, np.float32, np.float64)
|
||||
for order in range(0, 6):
|
||||
for data_dt in dts:
|
||||
these_data = data.astype(data_dt)
|
||||
for coord_dt in dts:
|
||||
# affine mapping
|
||||
mat = np.eye(2, dtype=coord_dt)
|
||||
off = np.zeros((2,), dtype=coord_dt)
|
||||
out = ndimage.affine_transform(these_data, mat, off)
|
||||
assert_array_almost_equal(these_data, out)
|
||||
# map coordinates
|
||||
coords_m1 = idx.astype(coord_dt) - 1
|
||||
coords_p10 = idx.astype(coord_dt) + 10
|
||||
out = ndimage.map_coordinates(these_data, coords_m1, order=order)
|
||||
assert_array_almost_equal(out, shifted_data)
|
||||
# check constant fill works
|
||||
out = ndimage.map_coordinates(these_data, coords_p10, order=order)
|
||||
assert_array_almost_equal(out, np.zeros((3,4)))
|
||||
# check shift and zoom
|
||||
out = ndimage.shift(these_data, 1)
|
||||
assert_array_almost_equal(out, shifted_data)
|
||||
out = ndimage.zoom(these_data, 1)
|
||||
assert_array_almost_equal(these_data, out)
|
||||
|
||||
|
||||
@pytest.mark.xfail(not sys.platform == 'darwin', reason="runs only on darwin")
|
||||
def test_uint64_max():
|
||||
# Test interpolation respects uint64 max. Reported to fail at least on
|
||||
# win32 (due to the 32 bit visual C compiler using signed int64 when
|
||||
# converting between uint64 to double) and Debian on s390x.
|
||||
# Interpolation is always done in double precision floating point, so
|
||||
# we use the largest uint64 value for which int(float(big)) still fits
|
||||
# in a uint64.
|
||||
big = 2**64 - 1025
|
||||
arr = np.array([big, big, big], dtype=np.uint64)
|
||||
# Tests geometric transform (map_coordinates, affine_transform)
|
||||
inds = np.indices(arr.shape) - 0.1
|
||||
x = ndimage.map_coordinates(arr, inds)
|
||||
assert_(x[1] == int(float(big)))
|
||||
assert_(x[2] == int(float(big)))
|
||||
# Tests zoom / shift
|
||||
x = ndimage.shift(arr, 0.1)
|
||||
assert_(x[1] == int(float(big)))
|
||||
assert_(x[2] == int(float(big)))
|
||||
@@ -0,0 +1,447 @@
|
||||
''' Some tests for filters '''
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import sys
|
||||
import numpy as np
|
||||
|
||||
from numpy.testing import (assert_equal, assert_allclose,
|
||||
assert_array_equal, assert_almost_equal)
|
||||
from pytest import raises as assert_raises
|
||||
|
||||
import scipy.ndimage as sndi
|
||||
from scipy.ndimage.filters import _gaussian_kernel1d, rank_filter
|
||||
from scipy._lib._numpy_compat import suppress_warnings
|
||||
|
||||
def test_ticket_701():
|
||||
# Test generic filter sizes
|
||||
arr = np.arange(4).reshape((2,2))
|
||||
func = lambda x: np.min(x)
|
||||
res = sndi.generic_filter(arr, func, size=(1,1))
|
||||
# The following raises an error unless ticket 701 is fixed
|
||||
res2 = sndi.generic_filter(arr, func, size=1)
|
||||
assert_equal(res, res2)
|
||||
|
||||
|
||||
def test_gh_5430():
|
||||
# At least one of these raises an error unless gh-5430 is
|
||||
# fixed. In py2k an int is implemented using a C long, so
|
||||
# which one fails depends on your system. In py3k there is only
|
||||
# one arbitrary precision integer type, so both should fail.
|
||||
sigma = np.int32(1)
|
||||
out = sndi._ni_support._normalize_sequence(sigma, 1)
|
||||
assert_equal(out, [sigma])
|
||||
sigma = np.int64(1)
|
||||
out = sndi._ni_support._normalize_sequence(sigma, 1)
|
||||
assert_equal(out, [sigma])
|
||||
# This worked before; make sure it still works
|
||||
sigma = 1
|
||||
out = sndi._ni_support._normalize_sequence(sigma, 1)
|
||||
assert_equal(out, [sigma])
|
||||
# This worked before; make sure it still works
|
||||
sigma = [1, 1]
|
||||
out = sndi._ni_support._normalize_sequence(sigma, 2)
|
||||
assert_equal(out, sigma)
|
||||
# Also include the OPs original example to make sure we fixed the issue
|
||||
x = np.random.normal(size=(256, 256))
|
||||
perlin = np.zeros_like(x)
|
||||
for i in 2**np.arange(6):
|
||||
perlin += sndi.filters.gaussian_filter(x, i, mode="wrap") * i**2
|
||||
# This also fixes gh-4106, show that the OPs example now runs.
|
||||
x = np.int64(21)
|
||||
sndi._ni_support._normalize_sequence(x, 0)
|
||||
|
||||
|
||||
def test_gaussian_kernel1d():
|
||||
radius = 10
|
||||
sigma = 2
|
||||
sigma2 = sigma * sigma
|
||||
x = np.arange(-radius, radius + 1, dtype=np.double)
|
||||
phi_x = np.exp(-0.5 * x * x / sigma2)
|
||||
phi_x /= phi_x.sum()
|
||||
assert_allclose(phi_x, _gaussian_kernel1d(sigma, 0, radius))
|
||||
assert_allclose(-phi_x * x / sigma2, _gaussian_kernel1d(sigma, 1, radius))
|
||||
assert_allclose(phi_x * (x * x / sigma2 - 1) / sigma2,
|
||||
_gaussian_kernel1d(sigma, 2, radius))
|
||||
assert_allclose(phi_x * (3 - x * x / sigma2) * x / (sigma2 * sigma2),
|
||||
_gaussian_kernel1d(sigma, 3, radius))
|
||||
|
||||
|
||||
def test_orders_gauss():
|
||||
# Check order inputs to Gaussians
|
||||
arr = np.zeros((1,))
|
||||
assert_equal(0, sndi.gaussian_filter(arr, 1, order=0))
|
||||
assert_equal(0, sndi.gaussian_filter(arr, 1, order=3))
|
||||
assert_raises(ValueError, sndi.gaussian_filter, arr, 1, -1)
|
||||
assert_equal(0, sndi.gaussian_filter1d(arr, 1, axis=-1, order=0))
|
||||
assert_equal(0, sndi.gaussian_filter1d(arr, 1, axis=-1, order=3))
|
||||
assert_raises(ValueError, sndi.gaussian_filter1d, arr, 1, -1, -1)
|
||||
|
||||
|
||||
def test_valid_origins():
|
||||
"""Regression test for #1311."""
|
||||
func = lambda x: np.mean(x)
|
||||
data = np.array([1,2,3,4,5], dtype=np.float64)
|
||||
assert_raises(ValueError, sndi.generic_filter, data, func, size=3,
|
||||
origin=2)
|
||||
func2 = lambda x, y: np.mean(x + y)
|
||||
assert_raises(ValueError, sndi.generic_filter1d, data, func,
|
||||
filter_size=3, origin=2)
|
||||
assert_raises(ValueError, sndi.percentile_filter, data, 0.2, size=3,
|
||||
origin=2)
|
||||
|
||||
for filter in [sndi.uniform_filter, sndi.minimum_filter,
|
||||
sndi.maximum_filter, sndi.maximum_filter1d,
|
||||
sndi.median_filter, sndi.minimum_filter1d]:
|
||||
# This should work, since for size == 3, the valid range for origin is
|
||||
# -1 to 1.
|
||||
list(filter(data, 3, origin=-1))
|
||||
list(filter(data, 3, origin=1))
|
||||
# Just check this raises an error instead of silently accepting or
|
||||
# segfaulting.
|
||||
assert_raises(ValueError, filter, data, 3, origin=2)
|
||||
|
||||
|
||||
def test_bad_convolve_and_correlate_origins():
|
||||
"""Regression test for gh-822."""
|
||||
# Before gh-822 was fixed, these would generate seg. faults or
|
||||
# other crashes on many system.
|
||||
assert_raises(ValueError, sndi.correlate1d,
|
||||
[0, 1, 2, 3, 4, 5], [1, 1, 2, 0], origin=2)
|
||||
assert_raises(ValueError, sndi.correlate,
|
||||
[0, 1, 2, 3, 4, 5], [0, 1, 2], origin=[2])
|
||||
assert_raises(ValueError, sndi.correlate,
|
||||
np.ones((3, 5)), np.ones((2, 2)), origin=[0, 1])
|
||||
|
||||
assert_raises(ValueError, sndi.convolve1d,
|
||||
np.arange(10), np.ones(3), origin=-2)
|
||||
assert_raises(ValueError, sndi.convolve,
|
||||
np.arange(10), np.ones(3), origin=[-2])
|
||||
assert_raises(ValueError, sndi.convolve,
|
||||
np.ones((3, 5)), np.ones((2, 2)), origin=[0, -2])
|
||||
|
||||
|
||||
def test_multiple_modes():
|
||||
# Test that the filters with multiple mode cababilities for different
|
||||
# dimensions give the same result as applying a single mode.
|
||||
arr = np.array([[1., 0., 0.],
|
||||
[1., 1., 0.],
|
||||
[0., 0., 0.]])
|
||||
|
||||
mode1 = 'reflect'
|
||||
mode2 = ['reflect', 'reflect']
|
||||
|
||||
assert_equal(sndi.gaussian_filter(arr, 1, mode=mode1),
|
||||
sndi.gaussian_filter(arr, 1, mode=mode2))
|
||||
assert_equal(sndi.prewitt(arr, mode=mode1),
|
||||
sndi.prewitt(arr, mode=mode2))
|
||||
assert_equal(sndi.sobel(arr, mode=mode1),
|
||||
sndi.sobel(arr, mode=mode2))
|
||||
assert_equal(sndi.laplace(arr, mode=mode1),
|
||||
sndi.laplace(arr, mode=mode2))
|
||||
assert_equal(sndi.gaussian_laplace(arr, 1, mode=mode1),
|
||||
sndi.gaussian_laplace(arr, 1, mode=mode2))
|
||||
assert_equal(sndi.maximum_filter(arr, size=5, mode=mode1),
|
||||
sndi.maximum_filter(arr, size=5, mode=mode2))
|
||||
assert_equal(sndi.minimum_filter(arr, size=5, mode=mode1),
|
||||
sndi.minimum_filter(arr, size=5, mode=mode2))
|
||||
assert_equal(sndi.gaussian_gradient_magnitude(arr, 1, mode=mode1),
|
||||
sndi.gaussian_gradient_magnitude(arr, 1, mode=mode2))
|
||||
assert_equal(sndi.uniform_filter(arr, 5, mode=mode1),
|
||||
sndi.uniform_filter(arr, 5, mode=mode2))
|
||||
|
||||
|
||||
def test_multiple_modes_sequentially():
|
||||
# Test that the filters with multiple mode cababilities for different
|
||||
# dimensions give the same result as applying the filters with
|
||||
# different modes sequentially
|
||||
arr = np.array([[1., 0., 0.],
|
||||
[1., 1., 0.],
|
||||
[0., 0., 0.]])
|
||||
|
||||
modes = ['reflect', 'wrap']
|
||||
|
||||
expected = sndi.gaussian_filter1d(arr, 1, axis=0, mode=modes[0])
|
||||
expected = sndi.gaussian_filter1d(expected, 1, axis=1, mode=modes[1])
|
||||
assert_equal(expected,
|
||||
sndi.gaussian_filter(arr, 1, mode=modes))
|
||||
|
||||
expected = sndi.uniform_filter1d(arr, 5, axis=0, mode=modes[0])
|
||||
expected = sndi.uniform_filter1d(expected, 5, axis=1, mode=modes[1])
|
||||
assert_equal(expected,
|
||||
sndi.uniform_filter(arr, 5, mode=modes))
|
||||
|
||||
expected = sndi.maximum_filter1d(arr, size=5, axis=0, mode=modes[0])
|
||||
expected = sndi.maximum_filter1d(expected, size=5, axis=1, mode=modes[1])
|
||||
assert_equal(expected,
|
||||
sndi.maximum_filter(arr, size=5, mode=modes))
|
||||
|
||||
expected = sndi.minimum_filter1d(arr, size=5, axis=0, mode=modes[0])
|
||||
expected = sndi.minimum_filter1d(expected, size=5, axis=1, mode=modes[1])
|
||||
assert_equal(expected,
|
||||
sndi.minimum_filter(arr, size=5, mode=modes))
|
||||
|
||||
|
||||
def test_multiple_modes_prewitt():
|
||||
# Test prewitt filter for multiple extrapolation modes
|
||||
arr = np.array([[1., 0., 0.],
|
||||
[1., 1., 0.],
|
||||
[0., 0., 0.]])
|
||||
|
||||
expected = np.array([[1., -3., 2.],
|
||||
[1., -2., 1.],
|
||||
[1., -1., 0.]])
|
||||
|
||||
modes = ['reflect', 'wrap']
|
||||
|
||||
assert_equal(expected,
|
||||
sndi.prewitt(arr, mode=modes))
|
||||
|
||||
|
||||
def test_multiple_modes_sobel():
|
||||
# Test sobel filter for multiple extrapolation modes
|
||||
arr = np.array([[1., 0., 0.],
|
||||
[1., 1., 0.],
|
||||
[0., 0., 0.]])
|
||||
|
||||
expected = np.array([[1., -4., 3.],
|
||||
[2., -3., 1.],
|
||||
[1., -1., 0.]])
|
||||
|
||||
modes = ['reflect', 'wrap']
|
||||
|
||||
assert_equal(expected,
|
||||
sndi.sobel(arr, mode=modes))
|
||||
|
||||
|
||||
def test_multiple_modes_laplace():
|
||||
# Test laplace filter for multiple extrapolation modes
|
||||
arr = np.array([[1., 0., 0.],
|
||||
[1., 1., 0.],
|
||||
[0., 0., 0.]])
|
||||
|
||||
expected = np.array([[-2., 2., 1.],
|
||||
[-2., -3., 2.],
|
||||
[1., 1., 0.]])
|
||||
|
||||
modes = ['reflect', 'wrap']
|
||||
|
||||
assert_equal(expected,
|
||||
sndi.laplace(arr, mode=modes))
|
||||
|
||||
|
||||
def test_multiple_modes_gaussian_laplace():
|
||||
# Test gaussian_laplace filter for multiple extrapolation modes
|
||||
arr = np.array([[1., 0., 0.],
|
||||
[1., 1., 0.],
|
||||
[0., 0., 0.]])
|
||||
|
||||
expected = np.array([[-0.28438687, 0.01559809, 0.19773499],
|
||||
[-0.36630503, -0.20069774, 0.07483620],
|
||||
[0.15849176, 0.18495566, 0.21934094]])
|
||||
|
||||
modes = ['reflect', 'wrap']
|
||||
|
||||
assert_almost_equal(expected,
|
||||
sndi.gaussian_laplace(arr, 1, mode=modes))
|
||||
|
||||
|
||||
def test_multiple_modes_gaussian_gradient_magnitude():
|
||||
# Test gaussian_gradient_magnitude filter for multiple
|
||||
# extrapolation modes
|
||||
arr = np.array([[1., 0., 0.],
|
||||
[1., 1., 0.],
|
||||
[0., 0., 0.]])
|
||||
|
||||
expected = np.array([[0.04928965, 0.09745625, 0.06405368],
|
||||
[0.23056905, 0.14025305, 0.04550846],
|
||||
[0.19894369, 0.14950060, 0.06796850]])
|
||||
|
||||
modes = ['reflect', 'wrap']
|
||||
|
||||
calculated = sndi.gaussian_gradient_magnitude(arr, 1, mode=modes)
|
||||
|
||||
assert_almost_equal(expected, calculated)
|
||||
|
||||
|
||||
def test_multiple_modes_uniform():
|
||||
# Test uniform filter for multiple extrapolation modes
|
||||
arr = np.array([[1., 0., 0.],
|
||||
[1., 1., 0.],
|
||||
[0., 0., 0.]])
|
||||
|
||||
expected = np.array([[0.32, 0.40, 0.48],
|
||||
[0.20, 0.28, 0.32],
|
||||
[0.28, 0.32, 0.40]])
|
||||
|
||||
modes = ['reflect', 'wrap']
|
||||
|
||||
assert_almost_equal(expected,
|
||||
sndi.uniform_filter(arr, 5, mode=modes))
|
||||
|
||||
|
||||
def test_gaussian_truncate():
|
||||
# Test that Gaussian filters can be truncated at different widths.
|
||||
# These tests only check that the result has the expected number
|
||||
# of nonzero elements.
|
||||
arr = np.zeros((100, 100), float)
|
||||
arr[50, 50] = 1
|
||||
num_nonzeros_2 = (sndi.gaussian_filter(arr, 5, truncate=2) > 0).sum()
|
||||
assert_equal(num_nonzeros_2, 21**2)
|
||||
num_nonzeros_5 = (sndi.gaussian_filter(arr, 5, truncate=5) > 0).sum()
|
||||
assert_equal(num_nonzeros_5, 51**2)
|
||||
|
||||
# Test truncate when sigma is a sequence.
|
||||
f = sndi.gaussian_filter(arr, [0.5, 2.5], truncate=3.5)
|
||||
fpos = f > 0
|
||||
n0 = fpos.any(axis=0).sum()
|
||||
# n0 should be 2*int(2.5*3.5 + 0.5) + 1
|
||||
assert_equal(n0, 19)
|
||||
n1 = fpos.any(axis=1).sum()
|
||||
# n1 should be 2*int(0.5*3.5 + 0.5) + 1
|
||||
assert_equal(n1, 5)
|
||||
|
||||
# Test gaussian_filter1d.
|
||||
x = np.zeros(51)
|
||||
x[25] = 1
|
||||
f = sndi.gaussian_filter1d(x, sigma=2, truncate=3.5)
|
||||
n = (f > 0).sum()
|
||||
assert_equal(n, 15)
|
||||
|
||||
# Test gaussian_laplace
|
||||
y = sndi.gaussian_laplace(x, sigma=2, truncate=3.5)
|
||||
nonzero_indices = np.nonzero(y != 0)[0]
|
||||
n = nonzero_indices.ptp() + 1
|
||||
assert_equal(n, 15)
|
||||
|
||||
# Test gaussian_gradient_magnitude
|
||||
y = sndi.gaussian_gradient_magnitude(x, sigma=2, truncate=3.5)
|
||||
nonzero_indices = np.nonzero(y != 0)[0]
|
||||
n = nonzero_indices.ptp() + 1
|
||||
assert_equal(n, 15)
|
||||
|
||||
|
||||
class TestThreading(object):
|
||||
def check_func_thread(self, n, fun, args, out):
|
||||
from threading import Thread
|
||||
thrds = [Thread(target=fun, args=args, kwargs={'output': out[x]}) for x in range(n)]
|
||||
[t.start() for t in thrds]
|
||||
[t.join() for t in thrds]
|
||||
|
||||
def check_func_serial(self, n, fun, args, out):
|
||||
for i in range(n):
|
||||
fun(*args, output=out[i])
|
||||
|
||||
def test_correlate1d(self):
|
||||
d = np.random.randn(5000)
|
||||
os = np.empty((4, d.size))
|
||||
ot = np.empty_like(os)
|
||||
self.check_func_serial(4, sndi.correlate1d, (d, np.arange(5)), os)
|
||||
self.check_func_thread(4, sndi.correlate1d, (d, np.arange(5)), ot)
|
||||
assert_array_equal(os, ot)
|
||||
|
||||
def test_correlate(self):
|
||||
d = np.random.randn(500, 500)
|
||||
k = np.random.randn(10, 10)
|
||||
os = np.empty([4] + list(d.shape))
|
||||
ot = np.empty_like(os)
|
||||
self.check_func_serial(4, sndi.correlate, (d, k), os)
|
||||
self.check_func_thread(4, sndi.correlate, (d, k), ot)
|
||||
assert_array_equal(os, ot)
|
||||
|
||||
def test_median_filter(self):
|
||||
d = np.random.randn(500, 500)
|
||||
os = np.empty([4] + list(d.shape))
|
||||
ot = np.empty_like(os)
|
||||
self.check_func_serial(4, sndi.median_filter, (d, 3), os)
|
||||
self.check_func_thread(4, sndi.median_filter, (d, 3), ot)
|
||||
assert_array_equal(os, ot)
|
||||
|
||||
def test_uniform_filter1d(self):
|
||||
d = np.random.randn(5000)
|
||||
os = np.empty((4, d.size))
|
||||
ot = np.empty_like(os)
|
||||
self.check_func_serial(4, sndi.uniform_filter1d, (d, 5), os)
|
||||
self.check_func_thread(4, sndi.uniform_filter1d, (d, 5), ot)
|
||||
assert_array_equal(os, ot)
|
||||
|
||||
def test_minmax_filter(self):
|
||||
d = np.random.randn(500, 500)
|
||||
os = np.empty([4] + list(d.shape))
|
||||
ot = np.empty_like(os)
|
||||
self.check_func_serial(4, sndi.maximum_filter, (d, 3), os)
|
||||
self.check_func_thread(4, sndi.maximum_filter, (d, 3), ot)
|
||||
assert_array_equal(os, ot)
|
||||
self.check_func_serial(4, sndi.minimum_filter, (d, 3), os)
|
||||
self.check_func_thread(4, sndi.minimum_filter, (d, 3), ot)
|
||||
assert_array_equal(os, ot)
|
||||
|
||||
|
||||
def test_minmaximum_filter1d():
|
||||
# Regression gh-3898
|
||||
in_ = np.arange(10)
|
||||
out = sndi.minimum_filter1d(in_, 1)
|
||||
assert_equal(in_, out)
|
||||
out = sndi.maximum_filter1d(in_, 1)
|
||||
assert_equal(in_, out)
|
||||
# Test reflect
|
||||
out = sndi.minimum_filter1d(in_, 5, mode='reflect')
|
||||
assert_equal([0, 0, 0, 1, 2, 3, 4, 5, 6, 7], out)
|
||||
out = sndi.maximum_filter1d(in_, 5, mode='reflect')
|
||||
assert_equal([2, 3, 4, 5, 6, 7, 8, 9, 9, 9], out)
|
||||
#Test constant
|
||||
out = sndi.minimum_filter1d(in_, 5, mode='constant', cval=-1)
|
||||
assert_equal([-1, -1, 0, 1, 2, 3, 4, 5, -1, -1], out)
|
||||
out = sndi.maximum_filter1d(in_, 5, mode='constant', cval=10)
|
||||
assert_equal([10, 10, 4, 5, 6, 7, 8, 9, 10, 10], out)
|
||||
# Test nearest
|
||||
out = sndi.minimum_filter1d(in_, 5, mode='nearest')
|
||||
assert_equal([0, 0, 0, 1, 2, 3, 4, 5, 6, 7], out)
|
||||
out = sndi.maximum_filter1d(in_, 5, mode='nearest')
|
||||
assert_equal([2, 3, 4, 5, 6, 7, 8, 9, 9, 9], out)
|
||||
# Test wrap
|
||||
out = sndi.minimum_filter1d(in_, 5, mode='wrap')
|
||||
assert_equal([0, 0, 0, 1, 2, 3, 4, 5, 0, 0], out)
|
||||
out = sndi.maximum_filter1d(in_, 5, mode='wrap')
|
||||
assert_equal([9, 9, 4, 5, 6, 7, 8, 9, 9, 9], out)
|
||||
|
||||
|
||||
def test_uniform_filter1d_roundoff_errors():
|
||||
# gh-6930
|
||||
in_ = np.repeat([0, 1, 0], [9, 9, 9])
|
||||
for filter_size in range(3, 10):
|
||||
out = sndi.uniform_filter1d(in_, filter_size)
|
||||
assert_equal(out.sum(), 10 - filter_size)
|
||||
|
||||
|
||||
def test_footprint_all_zeros():
|
||||
# regression test for gh-6876: footprint of all zeros segfaults
|
||||
arr = np.random.randint(0, 100, (100, 100))
|
||||
kernel = np.zeros((3, 3), bool)
|
||||
with assert_raises(ValueError):
|
||||
sndi.maximum_filter(arr, footprint=kernel)
|
||||
|
||||
def test_gaussian_filter():
|
||||
# Test gaussian filter with np.float16
|
||||
# gh-8207
|
||||
data = np.array([1],dtype = np.float16)
|
||||
sigma = 1.0
|
||||
with assert_raises(RuntimeError):
|
||||
sndi.gaussian_filter(data,sigma)
|
||||
|
||||
|
||||
def test_rank_filter_noninteger_rank():
|
||||
# regression test for issue 9388: ValueError for
|
||||
# non integer rank when performing rank_filter
|
||||
arr = np.random.random((10, 20, 30))
|
||||
assert_raises(TypeError, rank_filter, arr, 0.5,
|
||||
footprint=np.ones((1, 1, 10), dtype=bool))
|
||||
|
||||
|
||||
def test_size_footprint_both_set():
|
||||
# test for input validation, expect user warning when
|
||||
# size and footprint is set
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(UserWarning,
|
||||
"ignoring size because footprint is set")
|
||||
arr = np.random.random((10, 20, 30))
|
||||
rank_filter(arr, 5, size=2, footprint=np.ones((1, 1, 10), dtype=bool))
|
||||
@@ -0,0 +1,38 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import pytest
|
||||
from numpy.testing import assert_array_equal
|
||||
from scipy._lib._numpy_compat import suppress_warnings
|
||||
import scipy.ndimage as ndi
|
||||
|
||||
import os
|
||||
|
||||
try:
|
||||
from PIL import Image
|
||||
pil_missing = False
|
||||
except ImportError:
|
||||
pil_missing = True
|
||||
|
||||
|
||||
@pytest.mark.skipif(pil_missing, reason="The Python Image Library could not be found.")
|
||||
def test_imread():
|
||||
lp = os.path.join(os.path.dirname(__file__), 'dots.png')
|
||||
with suppress_warnings() as sup:
|
||||
# PIL causes a Py3k ResourceWarning
|
||||
sup.filter(message="unclosed file")
|
||||
sup.filter(DeprecationWarning)
|
||||
img = ndi.imread(lp, mode="RGB")
|
||||
assert_array_equal(img.shape, (300, 420, 3))
|
||||
|
||||
with suppress_warnings() as sup:
|
||||
# PIL causes a Py3k ResourceWarning
|
||||
sup.filter(message="unclosed file")
|
||||
sup.filter(DeprecationWarning)
|
||||
img = ndi.imread(lp, flatten=True)
|
||||
assert_array_equal(img.shape, (300, 420))
|
||||
|
||||
with open(lp, 'rb') as fobj:
|
||||
with suppress_warnings() as sup:
|
||||
sup.filter(DeprecationWarning)
|
||||
img = ndi.imread(fobj, mode="RGB")
|
||||
assert_array_equal(img.shape, (300, 420, 3))
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,47 @@
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
from numpy.testing import assert_array_almost_equal
|
||||
|
||||
import scipy.ndimage as ndimage
|
||||
|
||||
|
||||
def test_byte_order_median():
|
||||
"""Regression test for #413: median_filter does not handle bytes orders."""
|
||||
a = np.arange(9, dtype='<f4').reshape(3, 3)
|
||||
ref = ndimage.filters.median_filter(a,(3, 3))
|
||||
b = np.arange(9, dtype='>f4').reshape(3, 3)
|
||||
t = ndimage.filters.median_filter(b, (3, 3))
|
||||
assert_array_almost_equal(ref, t)
|
||||
|
||||
|
||||
def test_zoom_output_shape():
|
||||
"""Ticket #643"""
|
||||
x = np.arange(12).reshape((3,4))
|
||||
ndimage.zoom(x, 2, output=np.zeros((6,8)))
|
||||
|
||||
|
||||
def test_ticket_742():
|
||||
def SE(img, thresh=.7, size=4):
|
||||
mask = img > thresh
|
||||
rank = len(mask.shape)
|
||||
la, co = ndimage.label(mask,
|
||||
ndimage.generate_binary_structure(rank, rank))
|
||||
slices = ndimage.find_objects(la)
|
||||
|
||||
if np.dtype(np.intp) != np.dtype('i'):
|
||||
shape = (3,1240,1240)
|
||||
a = np.random.rand(np.product(shape)).reshape(shape)
|
||||
# shouldn't crash
|
||||
SE(a)
|
||||
|
||||
|
||||
def test_gh_issue_3025():
|
||||
"""Github issue #3025 - improper merging of labels"""
|
||||
d = np.zeros((60,320))
|
||||
d[:,:257] = 1
|
||||
d[:,260:] = 1
|
||||
d[36,257] = 1
|
||||
d[35,258] = 1
|
||||
d[35,259] = 1
|
||||
assert ndimage.label(d, np.ones((3,3)))[1] == 1
|
||||
@@ -0,0 +1,67 @@
|
||||
"""Tests for spline filtering."""
|
||||
from __future__ import division, print_function, absolute_import
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
from numpy.testing import assert_almost_equal
|
||||
|
||||
from scipy import ndimage
|
||||
|
||||
|
||||
def get_spline_knot_values(order):
|
||||
"""Knot values to the right of a B-spline's center."""
|
||||
knot_values = {0: [1],
|
||||
1: [1],
|
||||
2: [6, 1],
|
||||
3: [4, 1],
|
||||
4: [230, 76, 1],
|
||||
5: [66, 26, 1]}
|
||||
|
||||
return knot_values[order]
|
||||
|
||||
|
||||
def make_spline_knot_matrix(n, order, mode='mirror'):
|
||||
"""Matrix to invert to find the spline coefficients."""
|
||||
knot_values = get_spline_knot_values(order)
|
||||
|
||||
matrix = np.zeros((n, n))
|
||||
for diag, knot_value in enumerate(knot_values):
|
||||
indices = np.arange(diag, n)
|
||||
if diag == 0:
|
||||
matrix[indices, indices] = knot_value
|
||||
else:
|
||||
matrix[indices, indices - diag] = knot_value
|
||||
matrix[indices - diag, indices] = knot_value
|
||||
|
||||
knot_values_sum = knot_values[0] + 2 * sum(knot_values[1:])
|
||||
|
||||
if mode == 'mirror':
|
||||
start, step = 1, 1
|
||||
elif mode == 'reflect':
|
||||
start, step = 0, 1
|
||||
elif mode == 'wrap':
|
||||
start, step = -1, -1
|
||||
else:
|
||||
raise ValueError('unsupported mode {}'.format(mode))
|
||||
|
||||
for row in range(len(knot_values) - 1):
|
||||
for idx, knot_value in enumerate(knot_values[row + 1:]):
|
||||
matrix[row, start + step*idx] += knot_value
|
||||
matrix[-row - 1, -start - 1 - step*idx] += knot_value
|
||||
|
||||
return matrix / knot_values_sum
|
||||
|
||||
|
||||
@pytest.mark.parametrize('order', [0, 1, 2, 3, 4, 5])
|
||||
@pytest.mark.parametrize('mode', ['mirror', 'wrap', 'reflect'])
|
||||
def test_spline_filter_vs_matrix_solution(order, mode):
|
||||
n = 100
|
||||
eye = np.eye(n, dtype=float)
|
||||
spline_filter_axis_0 = ndimage.spline_filter1d(eye, axis=0, order=order,
|
||||
mode=mode)
|
||||
spline_filter_axis_1 = ndimage.spline_filter1d(eye, axis=1, order=order,
|
||||
mode=mode)
|
||||
matrix = make_spline_knot_matrix(n, order, mode=mode)
|
||||
assert_almost_equal(eye, np.dot(spline_filter_axis_0, matrix))
|
||||
assert_almost_equal(eye, np.dot(spline_filter_axis_1, matrix.T))
|
||||
Reference in New Issue
Block a user