def pipeline():
pipeline = Stream()
b = pipeline.map(generate_data)
b.sink(plot_data)
c = b.map(fit_data)
c.sink(plot_fit)
return pipeline
def make_pipeline(_output_sinks=True):
# link the pipeline up
namespace = link(*(pipeline_order + [median_gen, std_gen, z_score_gen]),
**general_namespace)
polarization_array = namespace["polarization_array"]
mask = namespace["mask"]
mean = namespace["mean"]
q = namespace["q"]
geometry = namespace["geometry"]
dark_corrected_foreground = namespace["dark_corrected_foreground"]
dark_corrected_background = namespace["dark_corrected_background"]
mask_kwargs = namespace["mask_kwargs"]
mask_setting = namespace["mask_setting"]
median = namespace["median"]
std = namespace["std"]
z_score = namespace["z_score"]
# Modify graph
# create filename nodes
filename_source = Stream(stream_name="filename")
filename_node = filename_source.map(lambda x: os.path.splitext(x)[0])
# write out mask
mask.combine_latest(
filename_node,
emit_on=0).sink(lambda x: fit2d_save(np.flipud(x[0]), x[1]))
mask.combine_latest(
filename_node,
emit_on=0).sink(lambda x: np.save(x[1] + "_mask.npy", x[0]))
if _output_sinks:
outs = [q, mean, median, std]
out_tup = tuple([[] for _ in outs])
out_sinks = tuple([k.sink(L.append) for k, L in zip(outs, out_tup)])
(mean.zip(q).combine_latest(
filename_node, emit_on=0).map(lambda l: (*l[0], l[1])).sink(
lambda x: save_output(x[1], x[0], x[2], "Q")))
(median.zip(q).combine_latest(
filename_node, emit_on=0).map(lambda l: (*l[0], l[1])).sink(
lambda x: save_output(x[1], x[0], x[2] + "_median", "Q")))
(std.zip(q).combine_latest(
filename_node, emit_on=0).map(lambda l: (*l[0], l[1])).sink(
lambda x: save_output(x[1], x[0], x[2] + "_std", "Q")))
(z_score.combine_latest(
filename_node, emit_on=0).starsink(lambda img, n: tifffile.imsave(
n + "_zscore.tif", data=img.astype(np.float32))))
# If running from a terminal don't output stuff into lists (too much mem)
return locals()
import pyFAI
import tifffile
from skbeam.io.fit2d import fit2d_save, read_fit2d_msk
from skbeam.io.save_powder_output import save_output
from streamz_ext import Stream
from xpdtools.pipelines.raw_pipeline import (polarization_array, mask, mean, q,
geometry,
dark_corrected_foreground,
dark_corrected_background,
z_score, std, median)
img_extensions = {'.tiff', '.edf', '.tif'}
# Modify graph
# create filename nodes
filename_source = Stream(stream_name='filename')
filename_node = (filename_source.map(lambda x: os.path.splitext(x)[0]))
# write out mask
mask.combine_latest(
filename_node, emit_on=0).sink(lambda x: fit2d_save(np.flipud(x[0]), x[1]))
mask.combine_latest(
filename_node, emit_on=0).sink(lambda x: np.save(x[1] + '_mask.npy', x[0]))
# write out chi
outs = [q, mean, median, std]
out_tup = tuple([[] for _ in outs])
out_sinks = tuple([k.sink(L.append) for k, L in zip(outs, out_tup)])
(mean.zip(q).combine_latest(filename_node,
emit_on=0).map(lambda l: (*l[0], l[1])).sink(
lambda x: save_output(x[1], x[0], x[2], 'Q')))
(median.zip(q).combine_latest(
overlay_mask, fq_getter, pdf_getter, sq_getter)
mask_setting = {'setting': 'auto'}
# Default kwargs
mask_kwargs = {}
fq_kwargs = dict(dataformat='QA', qmaxinst=28, qmax=25, rstep=np.pi / 25)
pdf_kwargs = dict(dataformat='QA', qmaxinst=28, qmax=22, rstep=np.pi / 22)
# Detector corrections
raw_foreground = Stream(stream_name='raw foreground')
raw_foreground_dark = Stream(stream_name='raw foreground dark')
raw_background = Stream(stream_name='raw background')
raw_background_dark = Stream(stream_name='raw background dark')
# Get the image shape for the binner
img_shape = raw_foreground.map(np.shape).unique(history=1)
dark_corrected_foreground = (raw_foreground.combine_latest(raw_foreground_dark,
emit_on=0).starmap(
op.sub))
dark_corrected_background = (raw_background.combine_latest(raw_background_dark,
emit_on=0).starmap(
op.sub))
bg_corrected_img = (dark_corrected_foreground.combine_latest(
dark_corrected_background,
emit_on=0).starmap(op.sub, stream_name='background corrected img'))
# Calibration management
wavelength = Stream(stream_name='wavelength')
calibrant = Stream(stream_name='calibrant')
detector = Stream(stream_name='detector')
is_calibration_img = Stream(stream_name='Is Calibration')
source = Stream()
def sleep_inc(x):
if x == 9:
raise RuntimeError()
plt.pause(1)
return x + 1
def print_sleep(x):
plt.pause(.1)
print(x)
b = source.map(sleep_inc)
b.sink(print_sleep)
c = b.map(sleep_inc)
c.sink(print_sleep)
gv = run_vis(
source,
source_node=True,
edge_style={"color": "k"},
node_label_style={"font_size": 15},
edge_label_style=lambda x: {"label": x["label"], "font_size": 15},
node_style=node_style,
force_draw=True,
)
plt.pause(.1)
def test_destroy_pipeline():
source = Stream()
pipeline = source.map(op.add).zip(source).sink(print)
destroy_pipeline(source)
assert pipeline.upstreams == []
def make_a():
in_a = Stream()
out_a = in_a.map(lambda x: x + 1)
return locals()
def make_a():
source = Stream()
out_a = source.map(lambda x: x + 1)
return locals()
gfit = GaussianFit(x, y)
gfit.refine()
plt.pause(1)
return gfit
def plot_fit(gfit):
ax2.cla()
l2a = ax2.plot(gfit.x, gfit.y, 'b.', label="observed Gaussian")
l2b = ax2.plot(gfit.x, gfit.yg, 'g-', label="calculated Gaussian")
ax2.legend()
fig.canvas.draw()
plt.pause(0.1)
b = source.map(generate_data)
b.sink(plot_data)
c = b.map(fit_data)
c.sink(plot_fit)
gv = run_vis(
source,
source_node=True,
edge_style={"color": "k"},
node_label_style={"font_size": 15},
edge_label_style=lambda x: {
"label": x["label"],
"font_size": 15
},
node_style=node_style,
def make_b():
out_a = Stream()
out_b = out_a.map(lambda x: x * 2)
return {"out_a": out_a, "out_b": out_b}
def make_a():
source = Stream()
out_a = source.map(lambda x: x + 1)
return {"in_a": source, "out_a": out_a}