Example #1
0
def crop_image(in_file, out_file, side, center=None):
    """Function to crop an h5 image and pad with zeros around it"""

    img = spimage.sp_image_read(in_file, 0)

    if not center:
        center = img.detector.image_center[:2]

    shifted = 0
    if img.shifted:
        shifted = 1
        img = spimage.sp_image_shift(img)

    cropped = spimage.sp_image_alloc(side, side, 1)
    cropped.image[:, :] = image_manipulation.crop_and_pad(
        img.image, center, side)
    cropped.mask[:, :] = image_manipulation.crop_and_pad(
        img.mask, center, side)

    if shifted:
        cropped = spimage.sp_image_shift(cropped)

    spimage.sp_image_write(cropped, out_file, 16)

    spimage.sp_image_free(img)
    spimage.sp_image_free(cropped)

    print("end")
Example #2
0
def intensities_array_to_h5(img0,msk0,cx=None,cy=None,cropLength=None,save_to_file=None):
    import spimage,imgtools
    Nx = img0.shape[1]
    Ny = img0.shape[0]
    img = img0
    msk = msk0
    if cropLength != None:
        img = imgtools.crop(img0,cropLength,center=[cy,cx])
        msk = imgtools.crop(msk0,cropLength,center=[cy,cx])
        Nx = cropLength
        Ny = cropLength
    elif cx != None and cy != None:
        img = imgtools.recenter(img0,cx,cy)
        msk = imgtools.recenter(msk0,cx,cy)
    I = spimage.sp_image_alloc(Nx,Ny,1)
    I.image[:,:] = img[:,:]
    I.mask[:,:] = msk[:,:]
    I2 = spimage.sp_image_shift(I)
    I2.shifted = 0
    I2.phased = 0
    spimage.sp_image_free(I)
    if save_to_file != None:
        spimage.sp_image_write(I2,save_to_file,0)
    else:
        return I2
Example #3
0
def crop_image(in_file, out_file, sideX, sideY = 0):
    if sideY == 0:
        sideY = sideX
    try:
        img = spimage.sp_image_read(in_file,0)
    except:
        print "Error: %s is not a readable .h5 file\n" % in_file
        exit(1)

    shifted = 0
    if img.shifted:
        shifted = 1
        img = spimage.sp_image_shift(img)

    print "shifted = ", shifted

    lowX = img.detector.image_center[0]-(sideX/2.0-0.5)
    highX = img.detector.image_center[0]+(sideX/2.0-0.5)
    lowY = img.detector.image_center[1]-(sideY/2.0-0.5)
    highY = img.detector.image_center[1]+(sideY/2.0-0.5)

    print lowX, " ", highX
    print lowY, " ", highY

    if lowX != pylab.floor(lowX):
        lowX = int(pylab.floor(lowX))
        highX = int(pylab.floor(highX))
        img.detector.image_center[0] -= 0.5
    else:
        lowX = int(lowX)
        highX = int(highX)
    if lowY != pylab.floor(lowY):
        lowY = int(pylab.floor(lowY))
        highY = int(pylab.floor(highY))
        img.detector.image_center[1] -= 0.5
    else:
        lowY = int(lowY)
        highY = int(highY)

    cropped = spimage.rectangle_crop(img,lowX,lowY,highX,highY)

    print "did crop"

    if shifted:
        cropped = spimage.sp_image_shift(cropped)

    print "shifted (or not)"

    print "write ", out_file

    #print "orientation = ", cropped.detector.orientation
    #print spimage.sp_3matrix_get(cropped.detector.orientation,0,0,0)

    try:
        spimage.sp_image_write(cropped,out_file,16)
    except:
        print "Error: can not write to %s\n" % out_file

    print "end"
Example #4
0
def prep_emc_output_for_phasing(input_file, output_file, corner_to_zero=False):
    "Sets all negative values in image to 0 and create a rectangular mask"
    img = spimage.sp_image_read(input_file, 0)
    #set all negative values to 0:
    img.image[:, :, :] = img.image.clip(0)
    #set corners of mask to 1:
    r_array = stuff.r_array_3D(img.image.shape[0])
    img.mask[r_array > img.image.shape[0] / 2. + 0.5] = 1
    if corner_to_zero:
        img.image[r_array > img.image.shape[0]] = 0.
    spimage.sp_image_write(img, output_file, 0)
Example #5
0
def to_png(input_dir, output_dir, plot_setup):
    files = read_files(input_dir)

    support_function = get_support_function(plot_setup.get_mask())

    for f in files:
        img = spimage.sp_image_read(f, 0)
        support_function(img)
        img = spimage.sp_image_shift(img)
        output_file = output_dir + "/" + f[:-2] + "png"
        spimage.sp_image_write(img, output_file, plot_setup.get_color())
        spimage.sp_image_free(img)
Example #6
0
def mask_center_and_negatives(img_file_name,
                              radius,
                              output_file_name,
                              save_file=True):
    """Creates a new mask around the center with given radius as well as masking out regions with negative values in the image."""
    msk = mask_center(img_file_name, radius, output_file_name, save_file=False)
    img = spimage.sp_image_read(img_file_name, 0)
    msk.mask[real(img.image) < 0.] = 0
    if save_file:
        spimage.sp_image_write(msk, output_file_name, 0)
    else:
        return (msk)
Example #7
0
def to_png(*arguments):
    color,shift_flag,support_flag = evaluate_arguments(arguments)
    files = read_files()

    shift_function = get_shift_function(shift_flag)
    support_function = get_support_function(support_flag)

    for f in files:
        img = spimage.sp_image_read(f,0)
        support_function(img)
        img = sp_image_shift(img)
        spimage.sp_image_write(img,f[:-2]+"png",color)
        spimage.sp_image_free(img)
Example #8
0
def image_to_png(in_filename, out_filename, colorscale, shift):
    try:
        img = spimage.sp_image_read(in_filename,0)
    except:
        raise TypeError("%s is not a readable file" % in_filename)

    if shift == 1:
        img = spimage.sp_image_shift(img)

    try:
        spimage.sp_image_write(img,out_filename,colorscale)
    except:
        raise TypeError("Can not write %s" % out_filename)
Example #9
0
def to_png(input_dir, output_dir, plot_setup):
    #color,shift_flag,support_flag = evaluate_arguments(arguments)
    files = read_files(input_dir)

    shift_function = get_shift_function(plot_setup.get_shift())
    support_function = get_support_function(plot_setup.get_mask())

    for f in files:
        img = spimage.sp_image_read(f,0)
        support_function(img)
        img = sp_image_shift(img)
        spimage.sp_image_write(img,output_dir+"/"+f[:-2]+"png",plot_setup.get_color())
        spimage.sp_image_free(img)
Example #10
0
def image_to_png(in_filename, out_filename, colorscale, shift):
    try:
        img = spimage.sp_image_read(in_filename, 0)
    except IOError:
        raise TypeError(f"{in_filename} is not a readable file")

    if shift == 1:
        img = spimage.sp_image_shift(img)

    try:
        spimage.sp_image_write(img, out_filename, colorscale)
    except IOError:
        raise TypeError(f"Can not write {out_filename}")
Example #11
0
def shift_image(in_file,out_file = 0):
    try:
        img = spimage.sp_image_read(in_file,0)
    except:
        raise IOError("Can't read %s" % in_file)

    img_s = spimage.sp_image_shift(img)

    if out_file == 0:
        out_file = in_file

    try:
        spimage.sp_image_write(img_s,out_file,0)
    except:
        print "Error: Can not write to %s" % out_file
def pnccd_to_image(infile, outfile):
    try:
        f = h5py.File(infile)
    except:
        raise IOError("Can't read %s. It may not be a pnCCD file." % filename)

    i1 = f.keys().index("data")
    i2 = f.values()[i1].keys().index("data1")

    data = f.values()[i1].values()[i2].value

    img = spimage.sp_image_alloc(pylab.shape(data)[0], pylab.shape(data)[1], 1)
    img.image[:, :] = data[:, :]
    spimage.sp_image_write(img, outfile, 0)
    spimage.sp_image_free(img)
Example #13
0
def shift_image(in_file, out_file=0):
    try:
        img = spimage.sp_image_read(in_file, 0)
    except IOError:
        raise IOError(f"Can't read {in_file}")

    img_s = spimage.sp_image_shift(img)

    if out_file == 0:
        out_file = in_file

    try:
        spimage.sp_image_write(img_s, out_file, 0)
    except IOError:
        print(f"Error: Can not write to {out_file}")
Example #14
0
def split_pnccd(filename):
    f = h5py.File(filename)

    i1 = f.keys().index('data')
    i2 = f.values()[i1].keys().index('data1')
    i2 = f.values()[i1].keys().index('data1')

    data2 = f.values()[i1].values()[i2].value

    data2_1 = spimage.sp_image_alloc(data2.shape[1]/2,data2.shape[0],1)
    data2_2 = spimage.sp_image_alloc(data2.shape[1]/2,data2.shape[0],1)
    data2_1.image[:,:] = data2[:,:(data2.shape[1]/2)]
    data2_2.image[:,:] = data2[:,(data2.shape[1]/2):]

    spimage.sp_image_write(data2_1,filename[:-3]+"_part1.h5",0)
    spimage.sp_image_write(data2_2,filename[:-3]+"_part2.h5",0)
Example #15
0
def mask_center(img_file_name, radius, output_file_name=None, save_file=True):
    """Create a new mask around the center with given radius"""
    img = spimage.sp_image_read(img_file_name, 0)
    r_array = stuff.r_array_3D(img.image.shape[0])
    img.mask[r_array < radius] = 0
    img.mask[r_array > radius] = 1
    new_mask = spimage.sp_image_alloc(*np.shape(img.mask))
    new_mask.mask[:, :, :] = img.mask
    new_mask.image[:, :, :] = img.image
    new_mask.shifted = img.shifted
    new_mask.scaled = img.scaled
    new_mask.detector = img.detector
    if save_file:
        spimage.sp_image_write(new_mask, output_file_name, 0)
    else:
        return (new_mask)
Example #16
0
def add_new_mask(img_file_name,
                 new_mask_file_name,
                 output_file_name,
                 imgtimesmask=False):
    img = spimage.sp_image_read(img_file_name, 0)
    new_mask = spimage.sp_image_read(new_mask_file_name, 0)
    new_img = spimage.sp_image_alloc(*shape(img.image))
    new_img.image[:, :, :] = img.image
    new_img.shifted = img.shifted
    new_img.scaled = img.scaled
    new_img.detector = img.detector
    new_img.mask[:, :, :] = new_mask.mask
    spimage.sp_image_write(new_img, output_file_name, 0)
    if imgtimesmask:
        new_img.image[:, :, :] = img.image * new_mask.mask
        spimage.sp_image_write(new_img, 'imgtimesmask.h5', 0)
Example #17
0
def shift_image(in_file,out_file = 0):
    try:
        img = spimage.sp_image_read(in_file,0)
    except:
        print "Error: Can not read image %s" % in_file
        return

    img_s = spimage.sp_image_shift(img)

    if out_file == 0:
        out_file = in_file

    try:
        spimage.sp_image_write(img_s,out_file,0)
    except:
        print "Error: Can not write to %s" % out_file
Example #18
0
def center_image(filename, outfile, sigma=3):
    """Finds a localized strong object and puts it in the center. The
    sigma variable describes the size of the object"""
    print("foo")
    if not os.path.isfile(filename):
        raise IOError("Can not find file {0}".format(filename))
    img = spimage.sp_image_read(filename, 0)
    x = (numpy.arange(img.image.shape[0], dtype='float64') -
         img.image.shape[0] / 2. + 0.5)
    y = (numpy.arange(img.image.shape[1], dtype='float64') -
         img.image.shape[1] / 2. + 0.5)
    z = (numpy.arange(img.image.shape[2], dtype='float64') -
         img.image.shape[2] / 2. + 0.5)
    kernel = numpy.exp(-(x[:, numpy.newaxis, numpy.newaxis]**2 +
                         y[numpy.newaxis, :, numpy.newaxis]**2 +
                         y[numpy.newaxis, numpy.newaxis, :]**2) / 2.0 /
                       sigma**2)

    img_ft = numpy.fft.fft2(numpy.fft.fftshift(img.image))
    kernel_ft = numpy.fft.fft2(numpy.fft.fftshift(kernel))
    kernel_ft *= numpy.conj(img_ft)
    bt = numpy.fft.ifft2(kernel_ft)

    min_v = 0.
    min_x = 0
    min_y = 0
    min_z = 0
    for x in range(bt.shape[0]):
        for y in range(bt.shape[1]):
            for z in range(bt.shape[2]):
                if abs(bt[z, y, x]) > min_v:
                    min_v = abs(bt[z, y, x])
                    min_x = x
                    min_y = y
                    min_z = z
    print(min_x, min_y, min_z)
    spimage.sp_image_translate(img, -(-min_z + bt.shape[0] // 2),
                               -(-min_y + bt.shape[1] // 2),
                               -(-min_x + bt.shape[2] // 2),
                               spimage.SP_TRANSLATE_WRAP_AROUND)
    shift = img

    spimage.sp_image_write(shift, outfile, 0)
    spimage.sp_image_free(img)
Example #19
0
def add_mask(path, number_of_files, output_file):
    """Reads in files in paths, outputs h5 file output_file with accumulative mask from input images saved in both image and mask"""
    imgs = [
        os.path.join(path, i) for i in os.listdir(path) if i.endswith('.h5')
    ]
    for img_file in imgs[:number_of_files]:
        img = spimage.sp_image_read(img_file, 0)
        try:
            msk_array = msk_array + img.mask
        except NameError:
            msk_array = img.mask
    msk_array[msk_array < msk_array.max()] = 0
    msk_array[msk_array != 0] = 1
    new = spimage.sp_image_alloc(
        numpy.shape(img.image)[0],
        numpy.shape(img.image)[1], 1)
    new.mask[:, :] = msk_array
    new.image[:, :] = msk_array
    spimage.sp_image_write(new, output_file, 0)
Example #20
0
def calc_average_img(r2, r1=0, r_skip=None, iteration=None):
    rundir_range = range(r1, r2)
    if r_skip != None:
        for i in r_skip:
            rundir_range.remove(i)
    fail = 0
    for r in rundir_range:
        run_dir = 'run_%04d' % r
        print run_dir
        if iteration == None:
            iteration = return_last_iteration_integer(
                '{r}/output_mnt/'.format(r=run_dir))
        with h5py.File('{r}/output_mnt/fmodel_{i}.h5'.format(
                r=run_dir, i=iteration)) as f:
            try:
                added_real += f['real'][...]
                added_imag += f['imag'][...]
            except NameError:
                added_real = f['real'][...]
                added_imag = f['imag'][...]
            except KeyError:
                print 'fail'
                fail += 1
            if r == r2 - 1:
                mask = f['mask'][:]
    added_real /= float(len(rundir_range) - fail)
    added_imag /= float(len(rundir_range) - fail)
    complex_fmodel = added_real + 1j * added_imag
    new = spimage.sp_image_alloc(*np.shape(added_real))
    new.phased = 1
    new.mask[:] = mask
    new.image[:] = complex_fmodel
    spimage.sp_image_write(
        new, 'avg_fmodel_runs_{i}_{j}_iteration{k}.h5'.format(i=r1,
                                                              j=r2,
                                                              k=iteration), 0)
    new.image[:, :, :] = fft.fftn(complex_fmodel)
    spimage.sp_image_write(
        new, 'avg_model_runs_{i}_{j}_iteration{k}.h5'.format(i=r1,
                                                             j=r2,
                                                             k=iteration), 0)
Example #21
0
def calc_average_img_translated(r2,
                                r1=0,
                                r_skip=None,
                                iteration=None,
                                reference_model=None):
    rundir_range = range(r1, r2)
    if r_skip != None:
        for i in r_skip:
            rundir_range.remove(i)
    for r in rundir_range:
        run_dir = 'run_%04d' % r
        print run_dir
        if iteration == None:
            iteration = return_last_iteration_integer(
                '{r}/output_mnt/'.format(r=run_dir))
        f = spimage.sp_image_read(
            '{r}/output_mnt/fmodel_{i}.h5'.format(r=run_dir, i=iteration), 0)
        if r == r1:
            if reference_model == None:
                ref = f
            else:
                ref = reference_model
            added_img = f.image[:]
            mask = f.mask[:]
        if r != r1:
            spimage.sp_image_superimpose(ref, f, 0)
        added_img += f.image[:]
    added_img /= float(len(rundir_range))
    new = spimage.sp_image_alloc(*np.shape(added_img))
    new.phased = 1
    new.mask[:] = mask
    new.image[:] = added_img
    spimage.sp_image_write(
        new, 'avg_fmodel_runs_{i}_{j}_iteration{k}.h5'.format(i=r1,
                                                              j=r2,
                                                              k=iteration), 0)
    new.image[:, :, :] = fft.fftn(added_img)
    spimage.sp_image_write(
        new, 'avg_model_runs_{i}_{j}_iteration{k}.h5'.format(i=r1,
                                                             j=r2,
                                                             k=iteration), 0)
Example #22
0
def slice_3D(fn, output_dir=''):
    #Takes 3 slices through the center along x,y and z from a 3D image and saves it as three new 2D images.
    img_3D = spimage.sp_image_read(fn, 0)
    dim = shape(img_3D.image)[0]
    img_2D = spimage.sp_image_alloc(dim, dim, 1)
    img_2D.shifted = img_3D.shifted
    img_2D.scaled = img_3D.scaled
    if img_3D.shifted == 0:
        s = dim / 2
    else:
        s = 0

    img_2D.image[:, :] = img_3D.image[s, :, :]
    img_2D.mask[:, :] = img_3D.mask[s, :, :]
    spimage.sp_image_write(img_2D,
                           output_dir + fn.split('.')[0] + '_x_slice.h5', 0)

    img_2D.image[:, :] = img_3D.image[:, s, :]
    img_2D.mask[:, :] = img_3D.mask[:, s, :]
    spimage.sp_image_write(img_2D,
                           output_dir + fn.split('.')[0] + '_y_slice.h5', 0)

    img_2D.image[:, :] = img_3D.image[:, :, s]
    img_2D.mask[:, :] = img_3D.mask[:, :, s]
    spimage.sp_image_write(img_2D,
                           output_dir + fn.split('.')[0] + '_z_slice.h5', 0)
Example #23
0
def calc_average_img(path, cutoff=None):
    if cutoff == None:
        run_folders = []
    run_folders = select_by_error_cutoff(path, cutoff)['run']
    for r in run_folders:
        img = spimage.sp_image_read(
            r +
            '/output_mnt/model_{n}.h5'.format(n=return_last_iteration_integer(
                os.path.join(r, 'output_mnt'))), 0)
        try:
            added_imgs = added_imgs + img.image
        except NameError:
            added_imgs = img.image
    avg_img = added_imgs / float(len(run_folders))
    new = spimage.sp_image_alloc(*np.shape(img.image))
    new.image[:, :, :] = avg_img
    spimage.sp_image_write(
        new,
        '{p}/average_final_model_{c}_{t}.h5'.format(p=path,
                                                    c=cutoff,
                                                    t=time.strftime('%Y%m%d')),
        0)
Example #24
0
def crop_image(in_file, out_file, side, center=None):
    """Function to crop an h5 image and pad with zeros around it"""

    img = spimage.sp_image_read(in_file, 0)

    if not center:
        center = img.detector.image_center[:2]

    shifted = 0
    if img.shifted:
        shifted = 1
        img = spimage.sp_image_shift(img)

    print "shifted = ", shifted

    # cropped = spimage.rectangle_crop(img,lowX,lowY,highX,highY)
    cropped = spimage.sp_image_alloc(side, side, 1)
    cropped.image[:, :] = image_manipulation.crop_and_pad(img.image, center, side)
    cropped.mask[:, :] = image_manipulation.crop_and_pad(img.mask, center, side)

    print "did crop"

    if shifted:
        cropped = spimage.sp_image_shift(cropped)

    print "shifted (or not)"

    print "write ", out_file

    # print "orientation = ", cropped.detector.orientation
    # print spimage.sp_3matrix_get(cropped.detector.orientation,0,0,0)

    spimage.sp_image_write(cropped, out_file, 16)

    spimage.sp_image_free(img)
    spimage.sp_image_free(cropped)

    print "end"
spimage.sp_phaser_init_model(phaser, None, spimage.SpModelRandomPhases)
spimage.sp_phaser_init_support(phaser, support, 0, 0)


def run_it(number_of_iterations):
    spimage.sp_phaser_iterate(phaser, number_of_iterations)


run_it(NUMBER_OF_ITERATIONS)

phaser.algorithm = phase_alg_refine
run_it(NUMBER_OF_REFINE_ITERATIONS)
# Output data
model = spimage.sp_phaser_model(phaser)
support = spimage.sp_phaser_support(phaser)
fmodel = spimage.sp_phaser_fmodel(phaser)
spimage.sp_image_write(model, OUTPUT_DIR + "run_{}_model.h5".format(run_id), 0)
spimage.sp_image_write(support,
                       OUTPUT_DIR + "run_{}_support.h5".format(run_id), 0)
spimage.sp_image_write(fmodel, OUTPUT_DIR + "run_{}_fmodel.h5".format(run_id),
                       0)

ereal = spimage.sp_phaser_ereal(phaser)
efourier = spimage.sp_phaser_efourier(phaser)

filename = OUTPUT_DIR + '/run_{}_error.h5'.format(run_id)

with h5py.File(filename, "w") as file_handle:
    file_handle.create_dataset('ereal', data=ereal)
    file_handle.create_dataset('efourier', data=efourier)
    # create phaser
    phaser = _spimage.sp_phaser_alloc()
    _spimage.sp_phaser_init(phaser, phase_alg, sup_alg, _spimage.SpEngineCUDA)
    _spimage.sp_phaser_set_amplitudes(phaser, amplitudes)
    _spimage.sp_phaser_init_model(phaser, real_space, 0)
    _spimage.sp_phaser_init_support(phaser, support, 0, 0)

    #real_space_s = _spimage.sp_image_shift(real_space)
    fourier_space = _spimage.sp_image_ifftw3(real_space)

    ereal_start = _numpy.sqrt((abs(real_space.image[~_numpy.bool8(support.image)])**2).sum() / (abs(real_space.image)**2).sum())
    efourier_start = _numpy.sqrt(((abs(fourier_space.image[_numpy.bool8(amplitudes.mask)]) - abs(amplitudes.image[_numpy.bool8(amplitudes.mask)]))**2).sum() / ((abs(amplitudes.image[_numpy.bool8(amplitudes.mask)])**2).sum() + (abs(fourier_space.image[~_numpy.bool8(amplitudes.mask)])**2).sum()))

    _spimage.sp_phaser_iterate(phaser, options.number_of_iterations)

    model_out = _spimage.sp_phaser_model(phaser)
    support_out = _spimage.sp_phaser_support(phaser)
    fmodel_out = _spimage.sp_phaser_fmodel(phaser)
    real_space_end = _spimage.sp_phaser_model_before_projection(phaser)
    fourier_space_end = _spimage.sp_phaser_fmodel(phaser)

    ereal_end = _numpy.sqrt((abs(real_space_end.image[~_numpy.bool8(support.image)])**2).sum() / (abs(real_space_end.image)**2).sum())
    efourier_end = _numpy.sqrt(((abs(fourier_space_end.image[_numpy.bool8(amplitudes.mask)]) - abs(amplitudes.image[_numpy.bool8(amplitudes.mask)]))**2).sum() / ((abs(amplitudes.image[_numpy.bool8(amplitudes.mask)])**2).sum() + (abs(fourier_space_end.image[~_numpy.bool8(amplitudes.mask)])**2).sum()))

    _spimage.sp_image_write(model_out, "%s/real_space-%s.h5" % (options.output_dir, options.output_affix), 0)
    _spimage.sp_image_write(support_out, "%s/support-%s.h5" % (options.output_dir, options.output_affix), 0)
    _spimage.sp_image_write(fmodel_out, "%s/fourier_space-%s.h5" % (options.output_dir, options.output_affix), 0)
    print "Ereal:    %g -> %g" % (ereal_start, ereal_end)
    print "Efourier: %g -> %g" % (efourier_start, efourier_end)

Example #27
0
np3 = np1[np.newaxis, np.newaxis, :] + a
number_of_scattered_photons = 10**int(
    np3.flatten()[index]) * (particle_size / 20)**2  #10 is smallest radius

array_size = particle_size + 5
#Generate diffraction pattern
particle = ElserParticle(array_size, particle_size, feature_size)
detected_intensity, diffracted_wave, support = particle.generate_pattern(
    pattern_size_pixels, detector_distance, detector_pixel_size, wavelength,
    number_of_scattered_photons)

#Write to file
img_detected_intensity = spimage_tools.image_from_array(detected_intensity)
img_diffracted_wave = spimage_tools.image_from_array(diffracted_wave)
img_support = spimage_tools.image_from_array(support)

version = 'testrun'

output_dir = '/scratch/fhgfs/elsin/' + version + '/particles/'
shell_functions.mkdir_p(output_dir)

filename1 = output_dir + '/p{0:06d}'.format(index) + '_detected_intensity.h5'
filename2 = output_dir + '/p{0:06d}'.format(index) + '_diffracted_wave.h5'
filename3 = output_dir + '/p{0:06d}'.format(index) + '_support.h5'
spimage.sp_image_write(img_detected_intensity, filename1, 0)
spimage.sp_image_write(img_diffracted_wave, filename2, 0)
spimage.sp_image_write(img_support, filename3, 0)

image = np.fft.fftshift(np.fft.fft2(np.fft.fftshift(diffracted_wave)))
plt.imsave(output_dir + '/p{0:06d}'.format(index) + 'img.png', abs(image))
Example #28
0
 def process(self, f):
     img = spimage.sp_image_read(f,0)
     img = self.process_function(img)
     spimage.sp_image_write(img,self.out_dir+"/"+f[:-2]+"png",self.color)
     spimage.sp_image_free(img)
Example #29
0
 def process(self, f):
     img = spimage.sp_image_read(f, 0)
     img = self.process_function(img)
     output_file = self.out_dir + "/" + f[:-2] + "png"
     spimage.sp_image_write(img, output_file, self.color)
     spimage.sp_image_free(img)

def run_it(number_of_iterations):
    spimage.sp_phaser_iterate(phaser, number_of_iterations)


run_it(NUMBER_OF_ITERATIONS)

phaser.algorithm = phase_alg_refine
run_it(NUMBER_OF_REFINE_ITERATIONS)
#Output data
model = spimage.sp_phaser_model(phaser)
support = spimage.sp_phaser_support(phaser)
fmodel = spimage.sp_phaser_fmodel(phaser)
spimage.sp_image_write(
    model, OUTPUT_DIR + "index{0:06d}".format(index) +
    "run{0:06d}model.h5".format(run), 0)
spimage.sp_image_write(
    support, OUTPUT_DIR + "index{0:06d}".format(index) +
    "run{0:06d}support.h5".format(run), 0)
spimage.sp_image_write(
    fmodel, OUTPUT_DIR + "index{0:06d}".format(index) +
    "run{0:06d}fmodel.h5".format(run), 0)

ereal = spimage.sp_phaser_ereal(phaser)
efourier = spimage.sp_phaser_efourier(phaser)

filename = OUTPUT_DIR + 'index{0:06d}'.format(
    index) + 'run{0:06d}error.h5'.format(run)

with h5py.File(filename, 'w') as file_handle:
Example #31
0
img_real_space = spimage_tools.image_from_array(real_space)
img_real_space.phased = 0
img_real_space.shifted = 0
img_real_space.detector.detector_distance = settings['detector_distance']
img_real_space.detector.pixel_size[:] = settings['detector_pixel_size']
img_real_space.detector.wavelength = settings['wavelength']

output_dir = output_dir + 'particle_' + particle_id
shell_functions.mkdir_p(output_dir)

file1 = output_dir + '/particle_detected_intensity.h5'
file2 = output_dir + '/particle_diffracted_wave.h5'
file3 = output_dir + '/particle_support.h5'
file4 = output_dir + '/particle_shape.hdf5'
file5 = output_dir + '/particle_real_space.h5'

spimage.sp_image_write(img_detected_intensity, file1, 0)
spimage.sp_image_write(img_diffracted_wave, file2, 0)
spimage.sp_image_write(img_support, file3, 0)
spimage.sp_image_write(img_real_space, file5, 0)

with h5py.File(file4, "w") as f:
    dset = f.create_dataset("particle_matrix", data=particle.particle)
    dset.attrs['particle_size'] = particle_size
    dset.attrs['feature_size'] = feature_size
    dset.attrs['n_photons'] = settings['number_of_photons']

image = np.fft.fftshift(np.fft.fft2(np.fft.fftshift(diffracted_wave)))
plt.imsave(output_dir + '/particle_projection_img.png', abs(image))
Example #32
0
def to_png(*arguments):
    if len(arguments) <= 0:
        print("""
    This program converts all h5 files in the curren directory to png.
    Usage:  python_script_new_to_png [colorscale]

    Colorscales:
    Jet
    Gray
    PosNeg
    InvertedPosNeg
    Phase
    InvertedPhase
    Log (can be combined with the others)
    Shift (can be combined with the others)
    Support

    """)
        return
    elif not (isinstance(arguments, list) or isinstance(arguments, tuple)):
        print("function to_png takes must have a list or string input")
        return

    files = os.listdir('.')

    expr = re.compile('.h5$')
    h5_files = list(filter(expr.search, files))

    expr = re.compile('.png$')
    png_files = list(filter(expr.search, files))

    files = [f for f in h5_files if f[:-2]+"png" not in png_files]
    files.sort()

    print("Converting %d files" % len(files))

    log_flag = 0
    shift_flag = 0
    support_flag = 0
    color = 16

    for flag in arguments:
        if flag == 'PosNeg':
            color = 8192
        elif flag == 'InvertedPosNeg':
            color = 16384
        elif flag == 'Phase':
            color = 256
        elif flag == 'InvertedPhase':
            color = 4096
        elif flag == 'Jet':
            color = 16
        elif flag == 'Gray':
            color = 1
        elif flag == 'Log':
            log_flag = 1
        elif flag == 'Shift':
            shift_flag = 1
        elif flag == 'Support':
            support_flag = 1
        else:
            print("unknown flag %s" % flag)

    if log_flag == 1:
        color += 128

    # for f in files:
    #     img = spimage.sp_image_read(f[:-1],0)

    if shift_flag:
        def shift_function(img):
            ret = spimage.sp_image_shift(img)
            spimage.sp_image_free(img)
            return ret
    else:
        def shift_function(img):
            return img

    if support_flag:
        for f in files:
            img = spimage.sp_image_read(f, 0)
            spimage.sp_image_mask_to_image(img, img)
            img = shift_function(img)
            spimage.sp_image_write(img, f[:-2]+"png", color)
            spimage.sp_image_free(img)
    else:
        for f in files:
            img = spimage.sp_image_read(f, 0)
            img = shift_function(img)
            spimage.sp_image_write(img, f[:-2]+"png", color)
            spimage.sp_image_free(img)
Example #33
0
def image_to_png(arguments):
    if isinstance(arguments,str):
        arguments = [arguments]
    elif not isinstance(arguments,list):
        print "function to_png takes must have a list or string input"
        return

    if len(sys.argv) <= 1:
        print """
    Usage:  python_script_image_to_png <image_in.h5> <image_out.h5> [colorscale]

    Colorscales:
    Jet
    Gray
    PosNeg
    InvertedPosNeg
    Phase
    InvertedPhase
    Log (can be combined with the others)
    Shift (can be combined with the others)

    """
        exit(1)

    try:
        img = spimage.sp_image_read(arguments[0],0)
    except:
        print "Error: %s is not a readable .h5 file\n" % arguments[0]
        exit(1)

    log_flag = 0
    shift_flag = 0

    for flag in arguments[2:]:
        if flag == 'PosNeg':
            color = 8192
        elif flag == 'InvertedPosNeg':
            color = 16384
        elif flag == 'Phase':
            color = 256
        elif flag == 'InvertedPhase':
            color = 4096
        elif flag == 'Jet':
            color = 16
        elif flag == 'Gray':
            color = 1
        elif flag == 'Log':
            log_flag = 1
        elif flag == 'Shift':
            shift_flag = 1
        else:
            print "unknown flag %s" % flag

    if log_flag == 1:
        color += 128

    if shift_flag == 1:
        img = spimage.sp_image_shift(img)

    try:
        spimage.sp_image_write(img,arguments[1],color)
    except:
        print "Error: Can not write %s\n" % arguments[1]
        exit(1)
Example #34
0
def to_png(*arguments):
    if len(arguments) <= 0:
        print """
    This program converts all h5 files in the curren directory to png.
    Usage:  python_script_new_to_png [colorscale]

    Colorscales:
    Jet
    Gray
    PosNeg
    InvertedPosNeg
    Phase
    InvertedPhase
    Log (can be combined with the others)
    Shift (can be combined with the others)
    Support

    """
        return
    elif not (isinstance(arguments,list) or isinstance(arguments,tuple)):
        print "function to_png takes must have a list or string input"
        return


    #l = os.popen('ls').readlines()
    l = os.listdir('.')

    expr = re.compile('.h5$')
    h5_files = filter(expr.search,l)

    expr = re.compile('.png$')
    png_files = filter(expr.search,l)

    files = [f for f in h5_files if f[:-2]+"png" not in png_files]
    files.sort()

    print "Converting %d files" % len(files)

    log_flag = 0
    shift_flag = 0
    support_flag = 0
    color = 16

    for flag in arguments:
        if flag == 'PosNeg':
            color = 8192
        elif flag == 'InvertedPosNeg':
            color = 16384
        elif flag == 'Phase':
            color = 256
        elif flag == 'InvertedPhase':
            color = 4096
        elif flag == 'Jet':
            color = 16
        elif flag == 'Gray':
            color = 1
        elif flag == 'Log':
            log_flag = 1
        elif flag == 'Shift':
            shift_flag = 1
        elif flag == 'Support':
            support_flag = 1
        else:
            print "unknown flag %s" % flag

    if log_flag == 1:
        color += 128

    # for f in files:
    #     img = spimage.sp_image_read(f[:-1],0)

    def shift_function(img):
        return img

    if shift_flag:
        def shift_function(img):
            ret = spimage.sp_image_shift(img)
            spimage.sp_image_free(img)
            return ret

    if support_flag:
        for f in files:
            img = spimage.sp_image_read(f,0)
            spimage.sp_image_mask_to_image(img,img)
            img = shift_function(img)
            spimage.sp_image_write(img,f[:-2]+"png",color)
            spimage.sp_image_free(img)
    else:
        for f in files:
            img = spimage.sp_image_read(f,0)
            img = shift_function(img)
            spimage.sp_image_write(img,f[:-2]+"png",color)
            spimage.sp_image_free(img)
Example #35
0
 def process(self, f):
     #for f in files:
     img = spimage.sp_image_read(f,0)
     img = self.process_function(img)
     spimage.sp_image_write(img,f[:-2]+"png",self.color)
     spimage.sp_image_free(img)
Example #36
0
def put_neg_to_zero(image_file_name, output_file_name):
    img = spimage.sp_image_read(image_file_name, 0)
    new_img = img.image
    new_img[real(img.image) < 0.] = 0.
    img.image[:, :] = new_img
    spimage.sp_image_write(img, output_file_name, 0)
Example #37
0
    mask = _numpy.bool8(amplitudes.mask)
    efourier_start = _numpy.sqrt(
        ((abs(fourier_space.image[mask]) - abs(amplitudes.image[mask]))**
         2).sum() / ((abs(amplitudes.image[mask])**2).sum() +
                     (abs(fourier_space.image[~mask])**2).sum()))

    _spimage.sp_phaser_iterate(phaser, args.number_of_iterations)

    model_out = _spimage.sp_phaser_model(phaser)
    support_out = _spimage.sp_phaser_support(phaser)
    fmodel_out = _spimage.sp_phaser_fmodel(phaser)
    real_space_end = _spimage.sp_phaser_model_before_projection(phaser)
    fourier_space_end = _spimage.sp_phaser_fmodel(phaser)

    ereal_end = _numpy.sqrt((abs(real_space_end.image[~support])**2).sum() /
                            (abs(real_space_end.image)**2).sum())
    efourier_end = _numpy.sqrt(
        ((abs(fourier_space_end.image[mask]) - abs(amplitudes.image[mask]))**
         2).sum() / ((abs(amplitudes.image[mask])**2).sum() +
                     (abs(fourier_space_end.image[~mask])**2).sum()))

    _spimage.sp_image_write(model_out,
                            f"{args.outdir}/real_space-{args.affix}.h5", 0)
    _spimage.sp_image_write(support_out,
                            f"{args.outdir}/support-{args.affix}.h5", 0)
    _spimage.sp_image_write(fmodel_out,
                            f"{args.outdir}/fourier_space-{args.affix}.h5", 0)
    print("Ereal:    %g -> %g" % (ereal_start, ereal_end))
    print("Efourier: %g -> %g" % (efourier_start, efourier_end))