def main():
# Open a .ome.tif image from the Flexoscope.
impath = IJ.getFilePath("Choose .ome.tiff file")
channels = Opener.openUsingBioFormats(impath)
cal = channels.getCalibration()
# Show image
# imp.show() # straight to channels object sames memory.
# Split channels.
channels = ChannelSplitter().split(channels)
# Process channel 1.
# subtractzproject(imp, projectionMethod="Median")
channels[0] = subtractzproject(channels[0])
IJ.run(channels[0], "8-bit", "")
# Process channel 2.
# glidingprojection(imp, startframe=1, stopframe=None, glidingFlag=True, no_frames_per_integral=3, projectionmethod="Median")
channels[1] = glidingprojection(channels[1])
IJ.run(channels[1], "8-bit", "")
# [Optional] Process channel 3, 4, etc.
# subtractzproject(channels[3], projectionMethod="Median")
# glidingprojection(channels[3], startframe=1, stopframe=None, glidingFlag=True, no_frames_per_integral=3, projectionmethod="Median")
# IJ.run(channels[3], "8-bit", "")
# Merge channels.
merge = RGBStackMerge().mergeChannels(channels, True) # boolean keep
merge.setCalibration(cal)
merge.show()
def downsample_for_isotropy(imp, extra_downsample_factor=2.0, info=None):
"""downsample x, y pixel directions to get ~cubic voxels"""
title = imp.getTitle();
cal = imp.getCalibration();
if info is None:
pix_w = cal.pixelWidth;
pix_h = cal.pixelHeight;
pix_d = cal.pixelDepth;
else:
pix_w = info.get_xy_pixel_size_um();
pix_h = pix_w;
pix_d = info.get_z_plane_spacing_um();
im_w = imp.getWidth();
im_h = imp.getHeight();
im_d = imp.getNSlices();
print("original pixel whd = ({}, {}, {})".format(pix_w, pix_h, pix_d));
print("original image whd = ({}, {}, {})".format(im_w, im_h, im_d));
im_nch = imp.getNChannels();
if im_nch > 1:
split_ch = ChannelSplitter().split(imp);
else:
split_ch = [imp];
print("downsampling {} and making isotropic...".format(title));
IJ.showStatus("Downsampling and making ~isotropic...");
xy_scale = pix_h / (pix_d * extra_downsample_factor);
xy_scaled_h = int(xy_scale * im_h);
xy_scaled_w = int(xy_scale * im_w);
z_scale = 1/ extra_downsample_factor;
z_scaled_h = int(z_scale * im_d);
out_imps = [];
for ch_imp in split_ch:
print(ch_imp.getTitle());
sp = StackProcessor(ch_imp.getStack());
print((xy_scaled_w, xy_scaled_h));
stack = sp.resize(xy_scaled_w, xy_scaled_h, True);
xz_stack = rot_around_x(stack);
xz_sp = StackProcessor(xz_stack);
xz_stack = xz_sp.resize(xy_scaled_w, z_scaled_h, True);
out_stack = rot_around_x(xz_stack);
out_imps.append(ImagePlus("Isotropic downsampled {}".format(title), out_stack));
cal.setUnit('um');
cal.pixelWidth = im_w/xy_scaled_w * pix_w;
cal.pixelHeight = im_h/xy_scaled_h * pix_h;
cal.pixelDepth = im_d/z_scaled_h * pix_d;
print("new pixel whd = ({}, {}, {})".format(cal.pixelWidth, cal.pixelHeight, cal.pixelDepth));
imp.changes = False;
imp.close();
for ch_imp in split_ch:
ch_imp.close();
if len(out_imps) > 1:
out_imp = RGBStackMerge().mergeChannels(out_imps, False);
else:
out_imp = out_imps[0];
out_imp.setCalibration(cal);
print("new image whd = ({}, {}, {})".format(out_imp.getWidth(), out_imp.getHeight(), out_imp.getNSlices()));
print("...done downsampling {} and making isotropic. ".format(title));
IJ.showStatus("...done downsampling and making ~isotropic. ");
return out_imp;
def rot3d(imp, axis='x'):
"""pare back Slicer to implement whole-image, +90* rotations that return ImagePlus"""
if imp.getType()==ImagePlus.COLOR_256 or imp.getType()==ImagePlus.COLOR_RGB:
raise NotImplementedError("Handling of colour images isn't implemented yet");
IJ.showStatus("Rotating around {}-axis...".format(axis))
title = imp.getTitle();
original_cal = imp.getCalibration();
new_cal = original_cal;
if imp.getNChannels > 1:
split_ch = ChannelSplitter().split(imp);
else:
split_ch = [imp];
out_imps = [];
if axis=='x':
for ch_imp in split_ch:
input_stack = ch_imp.getStack();
output_stack = rot_around_x(input_stack);
out_imps.append(ImagePlus(title, output_stack));
new_cal.pixelHeight = original_cal.pixelDepth;
new_cal.pixelDepth = original_cal.pixelHeight;
elif axis=='y' or axis=='-y':
for ch_imp in split_ch:
if axis[0]=='-':
input_stack = StackProcessor(ch_imp.getStack()).rotateLeft();
else:
input_stack = StackProcessor(ch_imp.getStack()).rotateRight();
output_stack = rot_around_x(input_stack);
if axis[0]=='-':
final_stack = StackProcessor(output_stack).rotateLeft();
else:
final_stack = StackProcessor(output_stack).rotateRight();
out_imps.append(ImagePlus(title, final_stack));
new_cal.pixelWidth = original_cal.pixelDepth;
new_cal.pixelDepth = original_cal.pixelWidth;
elif axis=='z' or axis=='-z':
for ch_imp in split_ch:
if axis[0]=='-':
output_stack = StackProcessor(ch_imp.getStack()).rotateLeft();
else:
output_stack = StackProcessor(ch_imp.getStack()).rotateRight();
out_imps.append(ImagePlus(title, output_stack));
new_cal.pixelWidth = original_cal.pixelHeight;
new_cal.pixelHeight = original_cal.pixelWidth;
else:
raise NotImplementedError("Please check which axis you've chosen - if not (x, +/-y, +/-z) then it's not implemented...");
imp.changes = False;
imp.close();
if len(out_imps) > 1:
out_imp = RGBStackMerge().mergeChannels(out_imps, False);
else:
out_imp = out_imps[0];
out_imp.setCalibration(new_cal);
return out_imp;
