def run_script():
    '''Function to be run when this file is used as a script'''
    selected_mode, img1_in, img2_in = get_setup()
    if not selected_mode:
        return
    corrected_stack = drift.get_corrected_stack((img1_in, img2_in), mode=selected_mode)
    img1, img2 = tools.stack_to_list_of_imp(corrected_stack)
    img_ratio = ImageCalculator().run('Divide create', img2, img1)
    img_ratio.setTitle('Jump-ratio [%s divided by %s]' % (img2.getShortTitle(),
                                                          img1.getShortTitle())
                      )
    img_ratio.changes = True
    img_ratio.copyScale(img1_in)
    img_ratio.show()
    IJ.run(img_ratio, 'Enhance Contrast', 'saturated=0.35')
    # We want to optimise the lower displaylimit:
    minimum = img_ratio.getProcessor().getMin()
    maximum = img_ratio.getProcessor().getMax()
    stat = img_ratio.getStatistics(Stats.MEAN + Stats.STD_DEV)
    mean = stat.mean
    stdv = stat.stdDev
    if minimum < mean - stdv:
        if mean - stdv >= 0:
            img_ratio.getProcessor().setMinAndMax(mean - stdv, maximum)
        else:
            img_ratio.getProcessor().setMinAndMax(0, maximum)
        img_ratio.updateAndDraw()
Exemple #2
0
def process_pi_signal(path, position, unsynchronized=True):

    if unsynchronized:
        path_signal = path + "\\pi"
        path_signal_before = path_signal + "\\before"
        path_signal_after = path_signal + "\\after"
        path_signal_merged = path_signal + "\\merged"
        path_imp_before = path_signal_before + "\\pi_in-focusxy%sc1.tif" % position
        path_imp_after = path_signal_after + "\\pixy%sc1.tif" % position
        path_imp_merged = path_signal_merged + "\\merged.tif"
        path_imp_merged_sub = path_signal_merged + "\\merged_sub.tif"

        imp1 = IJ.openImage(path_imp_before)
        imp1.show()
        imp2 = IJ.openImage(path_imp_after)
        imp2.show()

        zp1 = ZProjector(imp1)
        zp1.setMethod(ZProjector.AVG_METHOD)
        zp1.doProjection()
        zpimp1 = zp1.getProjection()

        zp2 = ZProjector(imp2)
        zp2.setMethod(ZProjector.AVG_METHOD)
        zp2.doProjection()
        zpimp2 = zp2.getProjection()

        imp_sub1 = ImageCalculator().run("Subtract create stack", imp1, zpimp1)
        imp_sub1.show()

        imp_sub2 = ImageCalculator().run("Subtract create stack", imp2, zpimp2)
        imp_sub2.show()

        concatenate_files(imp1, imp2, path_imp_merged)
        concatenate_files(imp_sub1, imp_sub2, path_imp_merged_sub)

    else:
        path_signal = path + "\\pi\\seq0002xy%sc1.tif" % position
        path_sub = path + "\\pi\\sub.tif"

        imp = IJ.openImage(path_signal)
        imp.show()

        zp = ZProjector(imp)
        zp.setMethod(ZProjector.AVG_METHOD)
        zp.doProjection()
        zpimp = zp.getProjection()

        imp_sub = ImageCalculator().run("Subtract create stack", imp, zpimp)
        imp_sub.show()

        IJ.saveAs(imp_sub, "Tiff", path_sub)

        imp.changes = False
        imp.close()
        zpimp.changes = False
        zpimp.close()
        imp_sub.changes = False
        imp_sub.close()
Exemple #3
0
def process_caspase_signal(path_signal, path_imp, path_imp_out):

    path_imp = path_signal + path_imp
    imp = IJ.openImage(path_imp)
    imp.show()

    zp = ZProjector(imp)
    zp.setMethod(ZProjector.AVG_METHOD)
    zp.doProjection()
    zpimp = zp.getProjection()

    imp_sub = ImageCalculator().run("Subtract create stack", imp, zpimp)
    imp_sub.show()
    IJ.saveAs(imp_sub, "Tiff", path_signal + path_imp_out)

    imp.changes = False
    imp.close()
    imp_sub.changes = False
    imp_sub.close()
IJ.run(imp, "Duplicate...",
       "title=wy")  #create wy by rotating wx by 90 degrees
IJ.run("Rotate 90 Degrees Left")
imp2 = IJ.getImage()
imp2.changes = False

#integration in the phase domain by shifting Pi/2, see equation 21 in Frankot-Chellapa
A = ImageCalculator().run("Multiply create 32-bit stack", DZDX, imp)
B = ImageCalculator().run("Multiply create 32-bit stack", DZDY,
                          imp2)  # numerator of
C = ImageCalculator().run("Add create 32-bit stack", A, B)  # eq 21
D = ImageCalculator().run("Multiply create 32-bit", imp, imp)  # square wx
E = ImageCalculator().run("Multiply create 32-bit", imp2, imp2)  # square wy
F = ImageCalculator().run("Add create 32-bit", D, E)  # demnominator of eq 21
Z = ImageCalculator().run("Divide create 32-bit stack", C, F)  # solve eq 21
Z.show()
IJ.run("Inverse FFT")  #results of integration
IJ.run(
    "Stack to Images"
)  #separate real and imaginary... why does imaginary produce result? more reading needed.

#clean-up by closing un-necessary images
imp2.close()
DZDX.close()
DZDY.close()
imp.changes = False
imp.close()
A.changes = False
A.close()
Z.close()