def single_crystal_sweep(image,
detector,
num_peaks,
min_sigma=1,
step_size=1,
max_sigma=None,
progress_bar=False):
if max_sigma is None:
max_sigma = np.max(image.shape) // 2
sigmas = np.arange(min_sigma, max_sigma, step_size)
detectors = [copy(detector) for _ in sigmas]
for sigma, detector in noobar(zip(sigmas, detectors),
num_iter=len(detectors),
disable=not progress_bar):
gl = -gaussian_laplace(image, sigma)
points = find_local_peaks(gl, min_distance=10,
exclude_border=1) # .astype(float)
gl_val = gl[points[:, 0], points[:, 1]]
points = points[np.argsort(-gl_val)][:num_peaks]
points = refine_peaks(gl, points, model=Polynomial2D(), extent=3)
indices = detector.detect(points)
return detectors
def traverse_from_all(points,
adjacency,
max_per_point=1,
max_depth=None,
progress_bar=False):
# TODO: Docstring
clockwise = find_clockwise(points, adjacency)
traversals = []
for i, point in enumerate(
noobar(points, units='traversals', disable=not progress_bar)):
for j, k in enumerate(adjacency[i]):
edge = (i, k)
traversal, _ = clockwise_traversal_with_depth(
edge, adjacency, clockwise, max_depth)
traversals.append(traversal)
if i > max_per_point - 1:
break
structures = Structures(points, traversals, adjacency)
return structures
def refine_peaks(image, points, model, extent=3, region_shape='disk', progress_bar=False):
"""Refine the position intensity extrema to sub-pixel accuracy.
The positions of intensity extrema are refined by fitting a model function
to a region close to the pixel positions of local extrema.
Parameters
----------
image : ndarray
Input image.
points : Points object
Points object containing the pixel positions of local extrema
region : int or ndarray
model : PeakModel object
progress_bar : bool
If True, display a progress bar.
"""
if (extent % 2) == 0:
raise RuntimeError()
if region_shape is 'disk':
region = _disk(extent // 2, dtype=bool)
elif region_shape is 'square':
region = np.ones((extent,) * 2, dtype=bool)
else:
raise ValueError()
r = (np.array(region.shape) - 1) // 2
region = np.array(region).astype(bool)
refined = np.zeros_like(points, dtype=float)
# Point may be floats, if exclude_adjacent was passed
# to find_local_peaks. If so, round and cast.
if not issubclass(points.dtype.type, np.integer):
points = np.rint(points).astype(int)
X, Y = np.indices(image.shape)
u, v = np.indices(region.shape)
u = u[region] - r[0]
v = v[region] - r[1]
for i, p in enumerate(noobar(points, units='fits', disable=not progress_bar)):
x = X[p[0] - r[0]:p[0] + r[0] + 1, p[1] - r[1]:p[1] + r[1] + 1]
y = Y[p[0] - r[0]:p[0] + r[0] + 1, p[1] - r[1]:p[1] + r[1] + 1]
z = image[x, y][region]
model.fit(u, v, z)
x0, y0 = model.peak_position()
refined[i, :] = [x0 + p[0], y0 + p[1]]
return refined
def _get_mask(self, shape, mask, progress_bar=True):
# TODO: Speed up mask calculation
mask_array = np.zeros(shape)
extent = _fft_extent_2d(self._fft_image.shape)
centers = self._nyquist2pixels(self.centers -
np.array([extent[0], extent[-1]]))
for center in noobar(centers, disable=not progress_bar):
mask_array += self._get_mask_array(center, shape, mask)
mask_array[mask_array > 1] = 1
return mask_array
def register(self, A, B, progress_bar=True):
N, M = len(A), len(B)
self._A, self._B = A, B
self._rmsd = np.empty((N, M))
self._rmsd[:] = np.nan
if A == B:
indices = itertools.combinations(range(N), 2)
np.fill_diagonal(self._rmsd, 0)
total = N * (N - 1) // 2
else:
indices = itertools.product(range(N), range(M))
total = N * M
precalced = self._do_precalc(A, B)
for i, j in noobar(indices,
num_iter=total,
units='registrations',
disable=not progress_bar):
is_connected, permutations = self.is_connected(A[i], B[j])
if is_connected:
rmsd, permutation = self.get_rmsd(A[i], B[j], precalced,
permutations)
self._rmsd[i, j] = rmsd
if self.permutations is not None:
self._permutations[(A[i], B[j])] = permutation
if A == B:
self._rmsd[j, i] = self._rmsd[i, j]
return self._rmsd