def test_constraint_global_noisy(self):
hard_radius = 1.
constraints = dimer_global(1, self.im.ndim)
self.im.clear()
self.im.draw_clusters(10, 2, hard_radius, 2*self.separation,
2*self.diameter)
f0 = self.im.f(noise=self.pos_err)
f0['signal'] = 180
f0['size'] = 6.
result = refine_leastsq(f0, self.im.noisy_image(0.2*self.signal),
self.diameter, self.separation,
constraints=constraints,
param_mode=dict(signal='global',
size='global'),
options=dict(maxiter=1000))
dists = []
for _, f_cl in result.groupby('cluster'):
pos = result[['y', 'x']].values
dists.append(np.sqrt(np.sum(((pos[0] - pos[1])/np.array(self.im.size))**2)))
assert_allclose(dists, 2*hard_radius, atol=0.1)
assert_coordinates_close(result[self.im.pos_columns].values,
self.im.coords, 0.1)
assert_allclose(result['signal'].values, 200, atol=2)
assert_allclose(result['size'].values, 5.25, atol=1)
def test_constraint_global_noisy(self):
hard_radius = 1.
constraints = dimer_global(1, self.im.ndim)
self.im.clear()
self.im.draw_clusters(10, 2, hard_radius, 2 * self.separation,
2 * self.diameter)
f0 = self.im.f(noise=self.pos_err)
f0['signal'] = 180
f0['size'] = 6.
result = refine_leastsq(f0,
self.im.noisy_image(0.2 * self.signal),
self.diameter,
self.separation,
constraints=constraints,
param_mode=dict(signal='global',
size='global'),
options=dict(maxiter=1000))
dists = []
for _, f_cl in result.groupby('cluster'):
pos = result[['y', 'x']].values
dists.append(
np.sqrt(np.sum(
((pos[0] - pos[1]) / np.array(self.im.size))**2)))
assert_allclose(dists, 2 * hard_radius, atol=0.1)
assert_coordinates_close(result[self.im.pos_columns].values,
self.im.coords, 0.1)
assert_allclose(result['signal'].values, 200, atol=2)
assert_allclose(result['size'].values, 5.25, atol=1)
def test_constraint_global_dimer(self):
hard_radius = 1.
constraints = dimer_global(1, self.im.ndim)
self.im.clear()
self.im.draw_clusters(10, 2, hard_radius, 2 * self.separation,
2 * self.diameter)
f0 = self.im.f(noise=self.pos_err)
result = refine_leastsq(f0,
self.im(),
self.diameter,
self.separation,
constraints=constraints,
options=dict(maxiter=1000))
dists = []
for _, f_cl in result.groupby('cluster'):
pos = result[['y', 'x']].values
dists.append(
np.sqrt(np.sum(
((pos[0] - pos[1]) / np.array(self.im.size))**2)))
assert_allclose(dists, 2 * hard_radius, atol=0.01)
assert_coordinates_close(result[self.im.pos_columns].values,
self.im.coords, 0.1)
def test_multiple_overlapping(self):
self.im.clear()
self.im.draw_features(100, 15, self.diameter)
f0 = self.im.f(noise=self.pos_err)
result = refine_leastsq(f0, self.im(), self.diameter, self.separation)
assert_coordinates_close(result[self.im.pos_columns].values,
self.im.coords, 0.1)
def test_multiple_overlapping(self):
self.im.clear()
self.im.draw_features(100, 15, self.diameter)
f0 = self.im.f(noise=self.pos_err)
result = refine_leastsq(f0, self.im(), self.diameter, self.separation)
assert_coordinates_close(result[self.im.pos_columns].values,
self.im.coords, 0.1)
def test_var_global(self):
self.im.clear()
self.im.draw_features(100, 15, self.diameter)
f0 = self.im.f(noise=self.pos_err)
f0['signal'] = 180
result = refine_leastsq(f0, self.im(), self.diameter, self.separation,
param_mode=dict(signal='global'),
options=dict(maxiter=10000))
assert_coordinates_close(result[self.im.pos_columns].values,
self.im.coords, 0.1)
assert (result['signal'].values[1:] == result['signal'].values[:-1]).all()
assert_allclose(result['signal'].values, 200, atol=5)
def test_float_image(self):
separation = 20
angle = 45
im = np.zeros((128, 128), dtype=np.float64)
pos = [[64, 64], [64 + separation * np.sin(angle/180*np.pi),
64 + separation * np.cos(angle/180*np.pi)]]
# setup features: features with equal signal will always be
# detected by a grey dilation, so make them unequal
draw_feature(im, pos[0], 3, 240)
draw_feature(im, pos[1], 3, 250)
# find both of them
f = grey_dilation(im, separation - 1, precise=False)
assert_coordinates_close(f, pos, atol=1)
def test_var_global(self):
self.im.clear()
self.im.draw_features(100, 15, self.diameter)
f0 = self.im.f(noise=self.pos_err)
f0['signal'] = 180
result = refine_leastsq(f0, self.im(), self.diameter, self.separation,
param_mode=dict(signal='global'),
options=dict(maxiter=10000))
assert_coordinates_close(result[self.im.pos_columns].values,
self.im.coords, 0.1)
assert (result['signal'].values[1:] == result['signal'].values[:-1]).all()
assert_allclose(result['signal'].values, 200, atol=5)
def test_float_image(self):
separation = 20
angle = 45
im = np.zeros((128, 128), dtype=np.float64)
pos = [[64, 64],
[
64 + separation * np.sin(angle / 180 * np.pi),
64 + separation * np.cos(angle / 180 * np.pi)
]]
# setup features: features with equal signal will always be
# detected by a grey dilation, so make them unequal
draw_feature(im, pos[0], 3, 240)
draw_feature(im, pos[1], 3, 250)
# find both of them
f = grey_dilation(im, separation - 1, precise=False)
assert_coordinates_close(f, pos, atol=1)
def test_separation_anisotropic(self):
separation = (10, 20)
for angle in np.arange(0, 360, 15):
im = np.zeros((128, 128), dtype=np.uint8)
pos = [[64, 64], [64 + separation[0] * np.sin(angle/180*np.pi),
64 + separation[1] * np.cos(angle/180*np.pi)]]
# setup features: features with equal signal will always be
# detected by a grey dilation, so make them unequal
draw_feature(im, pos[0], 3, 240)
draw_feature(im, pos[1], 3, 250)
# find both of them
f = grey_dilation(im, (9, 19))
assert_coordinates_close(f, pos, atol=1)
# find only the brightest
f = grey_dilation(im, (11, 21))
assert_coordinates_close(f, pos[1:], atol=1)
def test_separation(self):
separation = 20
for angle in np.arange(0, 360, 15):
im = np.zeros((128, 128), dtype=np.uint8)
pos = [[64, 64], [64 + separation * np.sin(angle/180*np.pi),
64 + separation * np.cos(angle/180*np.pi)]]
# setup features: features with equal signal will always be
# detected by grey_dilation_legacy, so make them unequal
draw_feature(im, pos[0], 3, 240)
draw_feature(im, pos[1], 3, 250)
# find both of them
f = grey_dilation_legacy(im, separation - 1)
assert_coordinates_close(f, pos, atol=1)
# find only the brightest
f = grey_dilation_legacy(im, separation + 1)
assert_coordinates_close(f, pos[1:], atol=1)
def test_constraint_global_dimer(self):
hard_radius = 1.
constraints = dimer_global(1, self.im.ndim)
self.im.clear()
self.im.draw_clusters(10, 2, hard_radius, 2*self.separation,
2*self.diameter)
f0 = self.im.f(noise=self.pos_err)
result = refine_leastsq(f0, self.im(), self.diameter,
self.separation, constraints=constraints,
options=dict(maxiter=1000))
dists = []
for _, f_cl in result.groupby('cluster'):
pos = result[['y', 'x']].values
dists.append(np.sqrt(np.sum(((pos[0] - pos[1])/np.array(self.im.size))**2)))
assert_allclose(dists, 2*hard_radius, atol=0.01)
assert_coordinates_close(result[self.im.pos_columns].values,
self.im.coords, 0.1)
def test_separation_fast(self):
separation = 20
for angle in np.arange(0, 360, 15):
im = np.zeros((128, 128), dtype=np.uint8)
pos = [[64, 64],
[
64 + separation * np.sin(angle / 180 * np.pi),
64 + separation * np.cos(angle / 180 * np.pi)
]]
# setup features: features with equal signal will always be
# detected by a grey dilation, so make them unequal
draw_feature(im, pos[0], 3, 240)
draw_feature(im, pos[1], 3, 250)
# find both of them
f = grey_dilation(im, separation - 1, precise=False)
assert_coordinates_close(f, pos, atol=1)
# find only the brightest
if angle in [45, 135, 225, 315]:
# for unprecise, a too small square kernel is used, which is
# perfect for 45-degree angles
f = grey_dilation(im, separation + 1, precise=False)
assert_coordinates_close(f, pos[1:], atol=1)
else:
# but too small by a factor of sqrt(ndim) for 90-degree angles
f = grey_dilation(im,
separation * np.sqrt(2) + 1,
precise=False)
assert_coordinates_close(f, pos[1:], atol=1)
def test_separation_fast(self):
separation = 20
for angle in np.arange(0, 360, 15):
im = np.zeros((128, 128), dtype=np.uint8)
pos = [[64, 64], [64 + separation * np.sin(angle/180*np.pi),
64 + separation * np.cos(angle/180*np.pi)]]
# setup features: features with equal signal will always be
# detected by a grey dilation, so make them unequal
draw_feature(im, pos[0], 3, 240)
draw_feature(im, pos[1], 3, 250)
# find both of them
f = grey_dilation(im, separation - 1, precise=False)
assert_coordinates_close(f, pos, atol=1)
# find only the brightest
if angle in [45, 135, 225, 315]:
# for unprecise, a too small square kernel is used, which is
# perfect for 45-degree angles
f = grey_dilation(im, separation + 1, precise=False)
assert_coordinates_close(f, pos[1:], atol=1)
else:
# but too small by a factor of sqrt(ndim) for 90-degree angles
f = grey_dilation(im, separation*np.sqrt(2) + 1, precise=False)
assert_coordinates_close(f, pos[1:], atol=1)
def test_separation_anisotropic(self):
separation = (10, 20)
for angle in np.arange(0, 360, 15):
im = np.zeros((128, 128), dtype=np.uint8)
pos = [[64, 64],
[
64 + separation[0] * np.sin(angle / 180 * np.pi),
64 + separation[1] * np.cos(angle / 180 * np.pi)
]]
# setup features: features with equal signal will always be
# detected by a grey dilation, so make them unequal
draw_feature(im, pos[0], 3, 240)
draw_feature(im, pos[1], 3, 250)
# find both of them
f = grey_dilation(im, (9, 19))
assert_coordinates_close(f, pos, atol=1)
# find only the brightest
f = grey_dilation(im, (11, 21))
assert_coordinates_close(f, pos[1:], atol=1)
def test_separation(self):
separation = 20
for angle in np.arange(0, 360, 15):
im = np.zeros((128, 128), dtype=np.uint8)
pos = [[64, 64],
[
64 + separation * np.sin(angle / 180 * np.pi),
64 + separation * np.cos(angle / 180 * np.pi)
]]
# setup features: features with equal signal will always be
# detected by grey_dilation_legacy, so make them unequal
draw_feature(im, pos[0], 3, 240)
draw_feature(im, pos[1], 3, 250)
# find both of them
f = grey_dilation_legacy(im, separation - 1)
assert_coordinates_close(f, pos, atol=1)
# find only the brightest
f = grey_dilation_legacy(im, separation + 1)
assert_coordinates_close(f, pos[1:], atol=1)
