def circular_average(image,
calibrated_center,
threshold=-1,
nx=None,
pixel_size=None,
mask=None):
"""Circular average of the the image data
The circular average is also known as the radial integration
Parameters
----------
image : array
Image to compute the average as a function of radius
calibrated_center : tuple
The center of the image in pixel units
argument order should be (row, col)
threshold : int, optional
Ignore counts above `threshold`
nx : int, optional
Number of bins in R. Defaults to 100
pixel_size : tuple, optional
The size of a pixel (in a real unit, like mm).
argument order should be (pixel_height, pixel_width)
Returns
-------
bin_centers : array
The center of each bin in R. shape is (nx, )
ring_averages : array
Radial average of the image. shape is (nx, ).
"""
radial_val = utils.radial_grid(calibrated_center, image.shape, pixel_size)
if nx is None:
ps = np.min(pixel_size)
max_x = np.max(radial_val) / ps
min_x = np.min(radial_val) / ps
nx = int(max_x - min_x)
#print (nx)
if mask is None: mask = 1
bin_edges, sums, counts = bin_1D(np.ravel(radial_val * mask),
np.ravel(image * mask), nx)
th_mask = counts > threshold
ring_averages = sums[th_mask] / counts[th_mask]
bin_centers = utils.bin_edges_to_centers(bin_edges)[th_mask]
return bin_centers, ring_averages
def circular_average(image, calibrated_center, threshold=-1, nx=None,
pixel_size=None, mask=None):
"""Circular average of the the image data
The circular average is also known as the radial integration
Parameters
----------
image : array
Image to compute the average as a function of radius
calibrated_center : tuple
The center of the image in pixel units
argument order should be (row, col)
threshold : int, optional
Ignore counts above `threshold`
nx : int, optional
Number of bins in R. Defaults to 100
pixel_size : tuple, optional
The size of a pixel (in a real unit, like mm).
argument order should be (pixel_height, pixel_width)
Returns
-------
bin_centers : array
The center of each bin in R. shape is (nx, )
ring_averages : array
Radial average of the image. shape is (nx, ).
"""
radial_val = utils.radial_grid(calibrated_center, image.shape, pixel_size )
if nx is None:
ps =np.min( pixel_size )
max_x = np.max(radial_val)/ps
min_x = np.min(radial_val)/ps
nx = int(max_x - min_x)
#print (nx)
if mask is None: mask =1
bin_edges, sums, counts = bin_1D(np.ravel(radial_val * mask ),
np.ravel(image * mask), nx)
th_mask = counts > threshold
ring_averages = sums[th_mask] / counts[th_mask]
bin_centers = utils.bin_edges_to_centers(bin_edges)[th_mask]
return bin_centers, ring_averages
def _helper_check(pixel_list, inds, num_pix, edges, center,
img_dim, num_qs):
# recreate the indices using pixel_list and inds values
ty = np.zeros(img_dim).ravel()
ty[pixel_list] = inds
data = ty.reshape(img_dim[0], img_dim[1])
# get the grid values from the center
grid_values = core.radial_grid(img_dim, center)
# get the indices into a grid
zero_grid = np.zeros((img_dim[0], img_dim[1]))
for r in range(num_qs):
vl = (edges[r][0] <= grid_values) & (grid_values < edges[r][1])
zero_grid[vl] = r + 1
# check the num_pixels
num_pixels = []
for r in range(num_qs):
num_pixels.append(int((np.histogramdd(np.ravel(grid_values), bins=1,
range=[[edges[r][0],
(edges[r][1]
- 0.000001)]]))[0][0]))
assert_array_equal(num_pix, num_pixels)
def test_radial_grid():
a = core.radial_grid((3, 3), (7, 7))
assert_equal(a[3, 3], 0)
assert_equal(a[3, 4], 1)
def brownian(im_shape, step_scale=1, decay=30,
I_fluc_function=None, step_fluc_function=None):
"""
Return a generator that yields simulated images
of a dot moving around under brownian motion with varying intensity
Parameters
----------
im_shape : tuple
The shape of the image. The synthetic images gets emitted with the
label 'img'
step_scale : float, optional
The size of the random steps. This value get emitted with the label
'T'
decay : float, optional
The size of the spot
I_fluc_function : callable
Determine the maximum intensity of the spot as a function of count
Signature of ::
def func(count):
return I(count)
step_fluc_function : callable
Determine if step should change and new step value. Either return
the new step value or None. If the new step is None, then don't emit
a 'T' event, other wise change the temperature and emit the event
Signature of ::
def func(step, count):
if not change_step(count):
return new_step(step, count)
else:
return None
"""
# This code was ported from a class-based implementation,
# so the style of what follows is a little tortured but functional.
im_shape = np.asarray(im_shape)
scale = step_scale
if I_fluc_function is None:
I_fluc_function = lambda x: np.random.randn()
I_func = I_fluc_function
if step_fluc_function is None:
step_fluc_function = lambda step, count: None
if im_shape.ndim != 1 and len(im_shape) != 2:
raise ValueError("image shape must be 2 dimensional "
"you passed in {}".format(im_shape))
cur_position = np.asarray(im_shape) // 2
count = 0
while True:
# add a random step
step = np.random.randn(2) * scale
cur_position += step
# clip it
cur_position = np.array([np.clip(v, 0, mx) for
v, mx in zip(cur_position, im_shape)])
R = utils.radial_grid(cur_position,
im_shape)
I = I_func(count)
im = np.exp((-R**2 / decay)) * I
count += 1
yield im
