def get_udf_results(self, udf_results, roi):
from libertem.viz import visualize_simple
if udf_results['intensity'].data.dtype.kind == 'c':
return AnalysisResultSet(
self.get_complex_results(
udf_results['intensity'].data,
key_prefix="intensity",
title="intensity",
desc="sum of all frames",
default_lin=False,
))
return SumResultSet([
AnalysisResult(
raw_data=udf_results['intensity'].data,
visualized=visualize_simple(udf_results['intensity'].data,
logarithmic=True),
key="intensity",
title="intensity [log]",
desc="sum of frames log-scaled"),
AnalysisResult(raw_data=udf_results['intensity'].data,
visualized=visualize_simple(
udf_results['intensity'].data,
logarithmic=False),
key="intensity_lin",
title="intensity [lin]",
desc="sum of frames lin-scaled"),
])
def get_results(self, job_results):
img_sum, img_x, img_y = job_results[0], job_results[1], job_results[2]
ref_x = self.parameters["cx"]
ref_y = self.parameters["cy"]
x_centers = np.divide(img_x, img_sum) - ref_x
y_centers = np.divide(img_y, img_sum) - ref_y
d = divergence([x_centers, y_centers])
m = np.sqrt(x_centers**2 + y_centers**2)
f = CMAP_CIRCULAR_DEFAULT.rgb_from_vector((y_centers, x_centers))
return [
AnalysisResult(raw_data=(x_centers, y_centers),
visualized=f,
title="field",
desc="cubehelix colorwheel visualization"),
AnalysisResult(raw_data=m,
visualized=visualize_simple(m),
title="magnitude",
desc="magnitude of the vector field"),
AnalysisResult(raw_data=d,
visualized=visualize_simple(d),
title="divergence",
desc="divergence of the vector field"),
AnalysisResult(raw_data=x_centers,
visualized=visualize_simple(x_centers),
title="x",
desc="x component of the center"),
AnalysisResult(raw_data=y_centers,
visualized=visualize_simple(y_centers),
title="y",
desc="y component of the center"),
]
def get_generic_results(self, data, damage):
from libertem.viz import visualize_simple
if data.dtype.kind == 'c':
return SingleMaskResultSet(
self.get_complex_results(
data,
key_prefix='intensity',
title='intensity',
desc=self.get_description(),
damage=damage,
))
return SingleMaskResultSet([
AnalysisResult(raw_data=data,
visualized=visualize_simple(data, damage=damage),
key="intensity",
title="intensity [lin]",
desc=f'{self.get_description()} lin-scaled'),
AnalysisResult(raw_data=data,
visualized=visualize_simple(data,
logarithmic=True,
damage=damage),
key="intensity_log",
title="intensity [log]",
desc=f'{self.get_description()} log-scaled'),
])
def get_generic_results(self, data, damage):
from libertem.viz import visualize_simple
coords = self.get_coords()
if data.dtype.kind == 'c':
return AnalysisResultSet(
self.get_complex_results(
data,
key_prefix="intensity",
title="intensity",
desc="the frame at %s" % (coords, ),
damage=True,
default_lin=False,
))
return AnalysisResultSet([
AnalysisResult(raw_data=data,
visualized=visualize_simple(data,
logarithmic=True,
damage=True),
key="intensity",
title="intensity [log]",
desc="the frame at %s log-scaled" % (coords, )),
AnalysisResult(raw_data=data,
visualized=visualize_simple(data,
logarithmic=False,
damage=True),
key="intensity_lin",
title="intensity [lin]",
desc="the frame at %s lin-scaled" % (coords, )),
])
def get_complex_results(self,
job_result,
key_prefix,
title,
desc,
damage,
default_lin=True):
from libertem.viz import visualize_simple, CMAP_CIRCULAR_DEFAULT
damage = damage & np.isfinite(job_result)
magn = np.abs(job_result)
angle = np.angle(job_result)
wheel = CMAP_CIRCULAR_DEFAULT.rgb_from_vector(
(job_result.real, job_result.imag, 0), vmax=np.max(magn[damage]))
return [
# for compatability, the magnitude has key=key_prefix
AnalysisResult(
raw_data=magn,
visualized=visualize_simple(magn, damage=damage),
key=key_prefix if default_lin else f'{key_prefix}_lin',
title="%s [magn]" % title,
desc="%s [magn]" % desc,
),
AnalysisResult(
raw_data=magn,
visualized=visualize_simple(magn,
logarithmic=True,
damage=damage),
key=f'{key_prefix}_log' if default_lin else key_prefix,
title="%s [log(magn)]" % title,
desc="%s [log(magn)]" % desc,
),
AnalysisResult(
raw_data=job_result.real,
visualized=visualize_simple(job_result.real, damage=damage),
key="%s_real" % key_prefix,
title="%s [real]" % title,
desc="%s [real]" % desc,
),
AnalysisResult(
raw_data=job_result.imag,
visualized=visualize_simple(job_result.imag, damage=damage),
key="%s_imag" % key_prefix,
title="%s [imag]" % title,
desc="%s [imag]" % desc,
),
AnalysisResult(
raw_data=angle,
visualized=visualize_simple(angle, damage=damage),
key="%s_angle" % key_prefix,
title="%s [angle]" % title,
desc="%s [angle]" % desc,
),
AnalysisResult(
raw_data=job_result,
visualized=wheel,
key="%s_complex" % key_prefix,
title="%s [complex]" % title,
desc="%s [complex]" % desc,
),
]
def get_results(self, job_results):
data, coords = self.get_results_base(job_results)
real_rad = self.parameters.get("real_rad")
real_center = (self.parameters.get("real_centery"),
self.parameters.get("real_centerx"))
if data.dtype.kind == 'c':
return AnalysisResultSet(
self.get_complex_results(
job_results,
key_prefix="intensity",
title="intensity",
desc="the frame at %s" % (coords, ),
))
if not (real_center is None or real_rad is None):
sigshape = job_results.shape
real_mask = 1 - 1 * _make_circular_mask(
real_center[1], real_center[0], sigshape[1], sigshape[0],
real_rad)
visualized = visualize_simple(np.fft.fftshift(
abs(np.fft.fft2(data * real_mask))),
logarithmic=True)
else:
visualized = visualize_simple(np.fft.fftshift(
abs(np.fft.fft2(data))),
logarithmic=True)
return AnalysisResultSet([
AnalysisResult(raw_data=data,
visualized=visualized,
key="intensity",
title="intensity",
desc="the frame at %s" % (coords, )),
])
def get_results(self, job_results):
parameters = self.parameters
coords = [
"%s=%d" % (axis, parameters.get(axis)) for axis in ['x', 'y', 'z']
if axis in parameters
]
coords = " ".join(coords)
shape = tuple(self.dataset.shape.sig)
data = job_results.reshape(shape)
if data.dtype.kind == 'c':
return AnalysisResultSet(
self.get_complex_results(
job_results,
key_prefix="intensity",
title="intensity",
desc="the frame at %s" % (coords, ),
))
visualized = visualize_simple(data)
return AnalysisResultSet([
AnalysisResult(raw_data=data,
visualized=visualized,
key="intensity",
title="intensity",
desc="the frame at %s" % (coords, )),
])
def get_udf_results(self, udf_results, roi, damage):
from libertem.viz import visualize_simple
from sklearn.cluster import AgglomerativeClustering
from sklearn.feature_extraction.image import grid_to_graph
n_clust = self.parameters["n_clust"]
y, x = tuple(self.dataset.shape.nav)
connectivity = grid_to_graph(
# Transposed!
n_x=y,
n_y=x)
f = udf_results['intensity'].raw_data
feature_vector = f / np.abs(f).mean(axis=0)
clustering = AgglomerativeClustering(
affinity='euclidean',
n_clusters=n_clust,
linkage='ward',
connectivity=connectivity).fit(feature_vector)
labels = np.array(clustering.labels_ + 1)
return AnalysisResultSet([
AnalysisResult(raw_data=labels.reshape(self.dataset.shape.nav),
visualized=visualize_simple(labels.reshape(
self.dataset.shape.nav),
damage=damage),
key="intensity",
title="intensity",
desc="Labels for the clustering"),
])
def get_udf_results(self, udf_results, roi):
n_clust = self.parameters["n_clust"]
y, x = tuple(self.dataset.shape.nav)
connectivity = grid_to_graph(
# Transposed!
n_x=y,
n_y=x)
f = udf_results['intensity'].raw_data
feature_vector = f / np.abs(f).mean(axis=0)
clustering = AgglomerativeClustering(
affinity='euclidean',
n_clusters=n_clust,
linkage='ward',
connectivity=connectivity).fit(feature_vector)
labels = np.array(clustering.labels_ + 1)
return AnalysisResultSet([
AnalysisResult(
raw_data=udf_results['intensity'].data,
visualized=visualize_simple(
labels.reshape(self.dataset.shape.nav)),
key="intensity",
title="intensity",
desc="result from integration over mask in Fourier space"),
])
def get_udf_results(self, udf_results, roi, damage):
from libertem.viz import visualize_simple
sum_results = np.array(udf_results['intensity'])
real_rad = self.parameters.get("real_rad")
real_center = (self.parameters.get("real_centery"),
self.parameters.get("real_centerx"))
if not (real_center is None or real_rad is None):
sigshape = sum_results.shape
real_mask = 1 - 1 * _make_circular_mask(
real_center[1], real_center[0], sigshape[1], sigshape[0],
real_rad)
fft_result = np.log(
abs(np.fft.fftshift(np.fft.fft2(sum_results * real_mask))) + 1)
else:
fft_result = np.log(
abs(np.fft.fftshift(np.fft.fft2(sum_results))) + 1)
return AnalysisResultSet([
AnalysisResult(raw_data=sum_results,
visualized=visualize_simple(fft_result,
damage=True),
key="intensity",
title="intensity",
desc="fft of sum of all frames"),
])
def get_udf_results(self, udf_results, roi):
data = udf_results['intensity'].data
return AnalysisResultSet([
AnalysisResult(raw_data=data,
visualized=visualize_simple(data.reshape(self.dataset.shape.nav)),
key="intensity", title="intensity",
desc="result from integration over mask in Fourier space"),
])
def get_generic_results(self, img_sum, img_y, img_x):
ref_x = self.parameters["cx"]
ref_y = self.parameters["cy"]
y_centers_raw, x_centers_raw = center_shifts(img_sum, img_y, img_x, ref_y, ref_x)
shape = y_centers_raw.shape
if self.parameters["flip_y"]:
transform = flip_y()
else:
transform = identity()
# Transformations are applied right to left
transform = rotate_deg(self.parameters["scan_rotation"]) @ transform
y_centers, x_centers = transform @ (y_centers_raw.reshape(-1), x_centers_raw.reshape(-1))
y_centers = y_centers.reshape(shape)
x_centers = x_centers.reshape(shape)
if img_sum.dtype.kind == 'c':
x_real, x_imag = np.real(x_centers), np.imag(x_centers)
y_real, y_imag = np.real(y_centers), np.imag(y_centers)
return COMResultSet([
AnalysisResult(raw_data=x_real, visualized=visualize_simple(x_real),
key="x_real", title="x [real]", desc="x component of the center"),
AnalysisResult(raw_data=y_real, visualized=visualize_simple(y_real),
key="y_real", title="y [real]", desc="y component of the center"),
AnalysisResult(raw_data=x_imag, visualized=visualize_simple(x_imag),
key="x_imag", title="x [imag]", desc="x component of the center"),
AnalysisResult(raw_data=y_imag, visualized=visualize_simple(y_imag),
key="y_imag", title="y [imag]", desc="y component of the center"),
])
else:
f = CMAP_CIRCULAR_DEFAULT.rgb_from_vector((y_centers, x_centers))
d = divergence(y_centers, x_centers)
c = curl_2d(y_centers, x_centers)
m = magnitude(y_centers, x_centers)
return COMResultSet([
AnalysisResult(raw_data=(x_centers, y_centers), visualized=f,
key="field", title="field", desc="cubehelix colorwheel visualization",
include_in_download=False),
AnalysisResult(raw_data=m, visualized=visualize_simple(m),
key="magnitude", title="magnitude", desc="magnitude of the vector field"),
AnalysisResult(raw_data=d, visualized=visualize_simple(d),
key="divergence", title="divergence", desc="divergence of the vector field"),
AnalysisResult(raw_data=c, visualized=visualize_simple(c),
key="curl", title="curl", desc="curl of the 2D vector field"),
AnalysisResult(raw_data=x_centers, visualized=visualize_simple(x_centers),
key="x", title="x", desc="x component of the center"),
AnalysisResult(raw_data=y_centers, visualized=visualize_simple(y_centers),
key="y", title="y", desc="y component of the center"),
])
def get_results(self, job_results):
data = job_results[0]
return [
AnalysisResult(raw_data=data,
visualized=visualize_simple(data),
title="intensity",
desc="sum of all frames"),
]
def get_results(self, job_results):
data = job_results[0]
return [
AnalysisResult(
raw_data=data,
visualized=visualize_simple(data),
title="intensity",
desc="intensity of the integration over the selected point"),
]
def get_udf_results(self, udf_results, roi):
return AnalysisResultSet([
AnalysisResult(raw_data=udf_results['var'].data,
visualized=visualize_simple(udf_results['var'].data,
logarithmic=True),
key="intensity",
title="intensity",
desc="SD of frames"),
])
def get_udf_results(self, udf_results, roi):
return AnalysisResultSet([
AnalysisResult(raw_data=udf_results['intensity'],
visualized=visualize_simple(
udf_results['intensity'].data.reshape(
self.dataset.shape.nav)),
key="intensity",
title="intensity",
desc="result from frame integration"),
])
def get_complex_results(self, job_result, key_prefix, title, desc):
magn = np.abs(job_result)
angle = np.angle(job_result)
wheel = CMAP_CIRCULAR_DEFAULT.rgb_from_vector(
(job_result.imag, job_result.real))
return [
# for compatability, the magnitude has key=key_prefix
AnalysisResult(
raw_data=magn,
visualized=visualize_simple(magn),
key=key_prefix,
title="%s [magn]" % title,
desc="%s [magn]" % desc,
),
AnalysisResult(
raw_data=job_result.real,
visualized=visualize_simple(job_result.real),
key="%s_real" % key_prefix,
title="%s [real]" % title,
desc="%s [real]" % desc,
),
AnalysisResult(
raw_data=job_result.imag,
visualized=visualize_simple(job_result.imag),
key="%s_imag" % key_prefix,
title="%s [imag]" % title,
desc="%s [imag]" % desc,
),
AnalysisResult(
raw_data=angle,
visualized=visualize_simple(angle),
key="%s_angle" % key_prefix,
title="%s [angle]" % title,
desc="%s [angle]" % desc,
),
AnalysisResult(
raw_data=job_result,
visualized=wheel,
key="%s_complex" % key_prefix,
title="%s [complex]" % title,
desc="%s [complex]" % desc,
),
]
def get_udf_results(self, udf_results):
return AnalysisResultSet([
AnalysisResult(raw_data=udf_results['intensity'].data,
visualized=visualize_simple(
udf_results['intensity'].data.reshape(
self.dataset.shape.nav)),
key="intensity",
title="intensity",
desc="result from SD calculation over ring"),
])
def get_udf_results(self, udf_results, roi):
from libertem.viz import visualize_simple
udf_results = std.consolidate_result(udf_results)
return AnalysisResultSet([
AnalysisResult(raw_data=udf_results['var'].data,
visualized=visualize_simple(udf_results['var'].data,
logarithmic=True),
key="intensity",
title="intensity",
desc="SD of frames"),
])
def get_udf_results(self, udf_results, roi, damage):
from libertem.viz import visualize_simple
return AnalysisResultSet([
AnalysisResult(raw_data=udf_results['intensity'],
visualized=visualize_simple(
udf_results['intensity'].data.reshape(self.dataset.shape.nav),
damage=damage
),
key="intensity", title="intensity",
desc="result from frame integration"),
])
def get_udf_results(self, udf_results, roi):
from libertem.viz import visualize_simple
return AnalysisResultSet([
AnalysisResult(
raw_data=udf_results['std'].data,
visualized=visualize_simple(
udf_results['std'].data, logarithmic=True
),
key="intensity", title="intensity [log]",
desc="Standard deviation of frames log-scaled"
),
AnalysisResult(
raw_data=udf_results['std'],
visualized=visualize_simple(
udf_results['std'].data, logarithmic=False,
),
key="intensity_lin",
title="intensity [lin]",
desc="Standard deviation of frames lin-scaled"
),
])
def get_udf_results(self, udf_results, roi):
n_clust = self.parameters["n_clust"]
clustering = AgglomerativeClustering(
affinity='euclidean', n_clusters=n_clust, linkage='ward'
).fit(udf_results['feature_vec'].raw_data)
labels = np.array(clustering.labels_+1)
return AnalysisResultSet([
AnalysisResult(raw_data=udf_results['feature_vec'].data,
visualized=visualize_simple(
labels.reshape(self.dataset.shape.nav)),
key="intensity", title="intensity",
desc="result from integration over mask in Fourier space"),
])
def get_results(self, job_results):
shape = tuple(self.dataset.shape.nav)
img_sum, img_x, img_y = (
job_results[0].reshape(shape),
job_results[1].reshape(shape),
job_results[2].reshape(shape)
)
ref_x = self.parameters["cx"]
ref_y = self.parameters["cy"]
x_centers = np.divide(img_x, img_sum, where=img_sum != 0)
y_centers = np.divide(img_y, img_sum, where=img_sum != 0)
x_centers[img_sum == 0] = ref_x
y_centers[img_sum == 0] = ref_y
x_centers -= ref_x
y_centers -= ref_y
if img_sum.dtype.kind == 'c':
x_real, x_imag = np.real(x_centers), np.imag(x_centers)
y_real, y_imag = np.real(y_centers), np.imag(y_centers)
return AnalysisResultSet([
AnalysisResult(raw_data=x_real, visualized=visualize_simple(x_real),
key="x_real", title="x [real]", desc="x component of the center"),
AnalysisResult(raw_data=y_real, visualized=visualize_simple(y_real),
key="y_real", title="y [real]", desc="y component of the center"),
AnalysisResult(raw_data=x_imag, visualized=visualize_simple(x_imag),
key="x_imag", title="x [imag]", desc="x component of the center"),
AnalysisResult(raw_data=y_imag, visualized=visualize_simple(y_imag),
key="y_imag", title="y [imag]", desc="y component of the center"),
])
else:
f = CMAP_CIRCULAR_DEFAULT.rgb_from_vector((y_centers, x_centers))
d = divergence([x_centers, y_centers])
m = np.sqrt(x_centers**2 + y_centers**2)
return AnalysisResultSet([
AnalysisResult(raw_data=(x_centers, y_centers), visualized=f,
key="field", title="field", desc="cubehelix colorwheel visualization"),
AnalysisResult(raw_data=m, visualized=visualize_simple(m),
key="magnitude", title="magnitude", desc="magnitude of the vector field"),
AnalysisResult(raw_data=d, visualized=visualize_simple(d),
key="divergence", title="divergence", desc="divergence of the vector field"),
AnalysisResult(raw_data=x_centers, visualized=visualize_simple(x_centers),
key="x", title="x", desc="x component of the center"),
AnalysisResult(raw_data=y_centers, visualized=visualize_simple(y_centers),
key="y", title="y", desc="y component of the center"),
])
def get_generic_results(self, data):
if data.dtype.kind == 'c':
return SingleMaskResultSet(
self.get_complex_results(
data,
key_prefix='intensity',
title='intensity',
desc=self.get_description(),
)
)
return SingleMaskResultSet([
AnalysisResult(raw_data=data, visualized=visualize_simple(data),
key="intensity", title="intensity",
desc=self.get_description()),
])
def get_generic_results(self, img_sum, img_y, img_x):
ref_x = self.parameters["cx"]
ref_y = self.parameters["cy"]
y_centers, x_centers = center_shifts(img_sum, img_y, img_x, ref_y, ref_x)
if img_sum.dtype.kind == 'c':
x_real, x_imag = np.real(x_centers), np.imag(x_centers)
y_real, y_imag = np.real(y_centers), np.imag(y_centers)
return COMResultSet([
AnalysisResult(raw_data=x_real, visualized=visualize_simple(x_real),
key="x_real", title="x [real]", desc="x component of the center"),
AnalysisResult(raw_data=y_real, visualized=visualize_simple(y_real),
key="y_real", title="y [real]", desc="y component of the center"),
AnalysisResult(raw_data=x_imag, visualized=visualize_simple(x_imag),
key="x_imag", title="x [imag]", desc="x component of the center"),
AnalysisResult(raw_data=y_imag, visualized=visualize_simple(y_imag),
key="y_imag", title="y [imag]", desc="y component of the center"),
])
else:
f = CMAP_CIRCULAR_DEFAULT.rgb_from_vector((y_centers, x_centers))
d = divergence(y_centers, x_centers)
c = curl_2d(y_centers, x_centers)
m = magnitude(y_centers, x_centers)
return COMResultSet([
AnalysisResult(raw_data=(x_centers, y_centers), visualized=f,
key="field", title="field", desc="cubehelix colorwheel visualization",
include_in_download=False),
AnalysisResult(raw_data=m, visualized=visualize_simple(m),
key="magnitude", title="magnitude", desc="magnitude of the vector field"),
AnalysisResult(raw_data=d, visualized=visualize_simple(d),
key="divergence", title="divergence", desc="divergence of the vector field"),
AnalysisResult(raw_data=c, visualized=visualize_simple(c),
key="curl", title="curl", desc="curl of the 2D vector field"),
AnalysisResult(raw_data=x_centers, visualized=visualize_simple(x_centers),
key="x", title="x", desc="x component of the center"),
AnalysisResult(raw_data=y_centers, visualized=visualize_simple(y_centers),
key="y", title="y", desc="y component of the center"),
])
def get_results(self, job_results):
if job_results.dtype.kind == 'c':
return AnalysisResultSet(
self.get_complex_results(
job_results,
key_prefix="intensity",
title="intensity",
desc="sum of all frames",
))
return AnalysisResultSet([
AnalysisResult(raw_data=job_results,
visualized=visualize_simple(job_results),
key="intensity",
title="intensity",
desc="sum of all frames"),
])
def get_udf_results(self, udf_results, roi):
if udf_results['intensity'].data.dtype.kind == 'c':
return AnalysisResultSet(
self.get_complex_results(
udf_results['intensity'].data,
key_prefix="intensity",
title="intensity",
desc="sum of all frames",
)
)
return SumResultSet([
AnalysisResult(raw_data=udf_results['intensity'].data,
visualized=visualize_simple(
udf_results['intensity'].data, logarithmic=True
),
key="intensity", title="intensity", desc="sum of frames"),
])
def get_generic_results(self, data):
coords = self.get_coords()
if data.dtype.kind == 'c':
return AnalysisResultSet(
self.get_complex_results(
data,
key_prefix="intensity",
title="intensity",
desc="the frame at %s" % (coords, ),
))
visualized = visualize_simple(data, logarithmic=True)
return AnalysisResultSet([
AnalysisResult(raw_data=data,
visualized=visualized,
key="intensity",
title="intensity",
desc="the frame at %s" % (coords, )),
])
def get_results(self, job_results):
shape = tuple(self.dataset.shape.nav)
data = job_results[0].reshape(shape)
if data.dtype.kind == 'c':
return AnalysisResultSet(
self.get_complex_results(
data.reshape(shape),
key_prefix='intensity',
title='intensity',
desc="intensity of the integration over the selected ring",
))
return AnalysisResultSet([
AnalysisResult(
raw_data=data.reshape(shape),
visualized=visualize_simple(data),
key="intensity",
title="intensity",
desc="intensity of the integration over the selected ring"),
])
def get_generic_results(self, data):
if data.dtype.kind == 'c':
results = []
for idx in range(data.shape[-1]):
results.extend(
self.get_complex_results(
data[..., idx],
key_prefix="mask_%d" % idx,
title="mask %d" % idx,
desc="integrated intensity for mask %d" % idx,
))
return MasksResultSet(results)
return MasksResultSet([
AnalysisResult(raw_data=data[..., idx],
visualized=visualize_simple(data[..., idx]),
key="mask_%d" % idx,
title="mask %d" % idx,
desc="integrated intensity for mask %d" % idx)
for idx in range(data.shape[-1])
])
