Esempio n. 1
0
else:

    what2do = wpu.get_from_ini_file(inifname, 'Parameters', 'what2do')

    if 'DPC' in what2do:
        choices = [
            'DPC response function',
            'Curvature response function from diff data'
        ]
    else:
        choices = [
            'Curvature response function from diff data',
            'DPC response function'
        ]

    what2do = easyqt.get_choice('Pick one', choices=choices)

wpu.set_at_ini_file(inifname, 'Parameters', 'what2do', what2do)

# %% Target
# Target file is the shape wanted for the correction.

if len(sys.argv) > 2 or easyqt.get_yes_or_no(
        'Do you want to load a target file?'):

    if len(sys.argv) > 2:
        targetName = sys.argv[2]
    else:
        targetName = easyqt.get_file_names('the target file directory:')

        # use one image as the current state
Esempio n. 2
0
    os.mkdir(data_dir + '/output/')
except:
    pass

fname2save = data_dir + '/output/' + samplefileName.rsplit('_', 1)[0].rsplit(
    '/', 1)[1]

wpu.print_blue('MESSAGE: Loading files ' + samplefileName.rsplit('_', 1)[0] +
               '*.tif')

listOfDataFiles = glob.glob(samplefileName.rsplit('_', 2)[0] + '*.tif')
listOfDataFiles.sort()
nfiles = len(listOfDataFiles)

zvec_from = easyqt.get_choice(
    message='z distances is calculated or from table?',
    title='Title',
    choices=['Calculated', 'Tabled'])

# %%

if zvec_from == 'Calculated':

    startDist = easyqt.get_float(
        'Starting distance scan [mm]', title='Title', default_value=10) * 1e-3

    step_z_scan = easyqt.get_float(
        'Step size scan [mm]', title='Title', default_value=2) * 1e-3

    image_per_point = easyqt.get_int('Number of images by step',
                                     title='Title',
                                     default_value=1)
hc = constants.value('inverse meter-electron volt relationship')  # hc

wavelength = hc / easyqt.get_float("Photon Energy [KeV]",
                                   title='Experimental Values',
                                   default_value=25.0) * 1e-3

pixelSize = easyqt.get_float("Enter Pixel Size [um]",
                             title='Experimental Values',
                             default_value=.65) * 1e-6

gratingPeriod = easyqt.get_float("Enter CB Grating Period [um]",
                                 title='Experimental Values',
                                 default_value=3.4) * 1e-6

pattern = easyqt.get_choice(message='Select CB Grating Pattern',
                            title='Title',
                            choices=['Diagonal', 'Edge'])

if pattern == 'Diagonal':
    gratingPeriod *= 1.0 / np.sqrt(2.0)

elif pattern == 'Edge':
    gratingPeriod *= 1.0 / 2.0

sourceDistance = easyqt.get_float("Enter Distance to Source [m]",
                                  title='Experimental Values',
                                  default_value=40)

tvec_labels = np.array([
    0.008, 0.009, 0.010, 0.011, 0.012, 0.013, 0.014, 0.016, 0.017, 0.019,
    0.021, 0.023, 0.025, 0.028, 0.030, 0.033, 0.037, 0.040, 0.044, 0.049,
Esempio n. 4
0
def _intial_gui_setup():

    #    global inifname  # name of .ini file
    #    pwd, inifname = argvzero.rsplit('/', 1)
    #    inifname = pwd + '/.' + inifname.replace('.py', '.ini')

    defaults = wpu.load_ini_file(inifname)

    fname = easyqt.get_file_names("File to Plot (Pickle or sdf)")

    if fname == []:
        fname = defaults['Files'].get('file with thickness')

    else:
        fname = fname[0]
        defaults['Files']['file with thickness'] = fname

    wpu.print_blue('MESSAGE: Loading File: ' + fname)

    with open(inifname, 'w') as configfile:
        defaults.write(configfile)

    if defaults is None:
        p1 = ''
        p2 = 100e-6

    else:
        p1 = defaults['Parameters'].get('String for Titles')
        p2 = float(defaults['Parameters'].get('Nominal Radius For Fitting'))
        p3 = defaults['Parameters']['Diameter of active area for fitting']
        p4 = defaults['Parameters']['Lens Geometry']

    str4title = easyqt.get_string('String for Titles', 'Enter String', p1)

    if str4title != '':
        defaults['Parameters']['String for Titles'] = str4title

    wpu.print_blue('MESSAGE: Loading Pickle: ' + fname)

    if p4 == '2D Lens Stigmatic Lens':
        menu_choices4lensmode = [
            '2D Lens Stigmatic Lens', '1Dx Horizontal focusing',
            '1Dy Vertical focusing'
        ]
    elif p4 == '1Dx Horizontal focusing':
        menu_choices4lensmode = [
            '1Dx Horizontal focusing', '1Dy Vertical focusing',
            '2D Lens Stigmatic Lens'
        ]
    elif p4 == '1Dy Vertical focusing':
        menu_choices4lensmode = [
            '1Dy Vertical focusing', '1Dx Horizontal focusing',
            '2D Lens Stigmatic Lens'
        ]

    lensGeometry = easyqt.get_choice(message='Lens Geometry',
                                     title='Input Parameter',
                                     choices=menu_choices4lensmode)

    nominalRadius = easyqt.get_float(
        'Nominal Curvature Radius' + ' for Fitting [um]',
        title='Input Parameter',
        default_value=p2 * 1e6) * 1e-6

    diameter4fit_str = easyqt.get_string(
        'Diameter of active area for fitting [um]',
        title='Input Parameter',
        default_response=p3)

    diameter4fit_list = [float(a) * 1e-6 for a in diameter4fit_str.split(',')]

    defaults['Parameters']['Nominal Radius For Fitting'] = str(nominalRadius)
    defaults['Parameters'][
        'Diameter of active area for fitting'] = diameter4fit_str
    defaults['Parameters']['Lens Geometry'] = lensGeometry

    with open(inifname, 'w') as configfile:
        defaults.write(configfile)

    return fname, str4title, nominalRadius, diameter4fit_list, lensGeometry
Esempio n. 5
0
    return data2save, headerdic




# %%

if __name__ == '__main__':

    argv = sys.argv

    if len(argv) == 4:
        data, headerdic = save_profile_from_sdf(argv[1],
                                     nprofiles=int(argv[2]),
                                     direction=argv[3])

    else:

        data, headerdic = save_profile_from_sdf(easyqt.get_file_names()[0],
                                     nprofiles=easyqt.get_int('Number of profiles'),
                                     direction=easyqt.get_choice(choices=['Vertical', 'Horizontal']))

# %%
    plt.figure()

    for i in range(1, data.shape[1]):
        plt.plot(data[:,0], data[:,i]+1e-9)

    plt.show()

deafaultfileName = defaults['Files'].get('Reference')

# %% Load

if len(sys.argv) == 1:
    samplefileName = easyqt.get_file_names("Choose the reference file " +
                                           "for alignment")

    if samplefileName == []:
        samplefileName = deafaultfileName
    else:
        samplefileName = samplefileName[0]
        wpu.set_at_ini_file(inifname, 'Files', 'reference', samplefileName)

    optionRef = easyqt.get_choice(
        'Align images to reference ot to previous image?',
        title='Title',
        choices=['Reference', 'Previous', 'Manual'])

    fixRef = (optionRef == 'Reference')

    if optionRef != 'Manual':
        option = easyqt.get_choice('Crop or Pad?',
                                   title='Title',
                                   choices=['Pad', 'Crop'])
else:
    samplefileName = sys.argv[1]
    option = sys.argv[2]
    fixRef = ('Ref' in sys.argv[2])

displayPlots = False
def main():
    wpu._mpl_settings_4_nice_graphs()

    # =============================================================================
    # %% Load Image
    # =============================================================================

    originalDir = os.getcwd()

    samplefileName = easyqt.get_file_names("Choose one of the scan files")[0]

    data_dir = samplefileName.rsplit('/', 1)[0]
    os.chdir(data_dir)

    try:
        os.mkdir(data_dir + '/output/')
    except:
        pass

    fname2save = data_dir + '/output/' + samplefileName.rsplit(
        '_', 1)[0].rsplit('/', 1)[1]

    wpu.print_blue('MESSAGE: Loading files ' +
                   samplefileName.rsplit('_', 1)[0] + '*.tif')

    listOfDataFiles = glob.glob(samplefileName.rsplit('_', 2)[0] + '*.tif')
    listOfDataFiles.sort()
    nfiles = len(listOfDataFiles)

    zvec_from = easyqt.get_choice(
        message='z distances is calculated or from table?',
        title='Title',
        choices=['Calculated', 'Tabled'])

    # %%

    if zvec_from == 'Calculated':

        startDist = easyqt.get_float('Starting distance scan [mm]',
                                     title='Title',
                                     default_value=20) * 1e-3

        step_z_scan = easyqt.get_float(
            'Step size scan [mm]', title='Title', default_value=5) * 1e-3

        image_per_point = easyqt.get_int('Number of images by step',
                                         title='Title',
                                         default_value=1)

        zvec = np.linspace(
            startDist,
            startDist + step_z_scan * (nfiles / image_per_point - 1),
            int(nfiles / image_per_point))
        zvec = zvec.repeat(image_per_point)

        strideFile = easyqt.get_int('Stride (Use only every XX files)',
                                    title='Title',
                                    default_value=1)
        listOfDataFiles = listOfDataFiles[0::strideFile]
        zvec = zvec[0::strideFile]
        print(zvec)
    elif zvec_from == 'Tabled':

        zvec = np.loadtxt(
            easyqt.get_file_names("Table with the z distance values in mm")
            [0]) * 1e-3
        step_z_scan = np.mean(np.diff(zvec))

    if step_z_scan > 0:
        pass
    else:
        listOfDataFiles = listOfDataFiles[::-1]
        zvec = zvec[::-1]

    img = dxchange.read_tiff(listOfDataFiles[0])

    # =============================================================================
    # %% Experimental parameters
    # =============================================================================

    pixelSize = easyqt.get_float("Enter Pixel Size [um]",
                                 title='Experimental Values',
                                 default_value=.6500,
                                 decimals=5) * 1e-6

    gratingPeriod = easyqt.get_float("Enter CB Grating Period [um]",
                                     title='Experimental Values',
                                     default_value=4.8) * 1e-6

    pattern = easyqt.get_choice(message='Select CB Grating Pattern',
                                title='Title',
                                choices=['Diagonal', 'Edge'])
    #                            choices=['Edge', 'Diagonal'])

    sourceDistanceV = easyqt.get_float(
        "Enter Distance to Source\n in the VERTICAL [m]",
        title='Experimental Values',
        default_value=-0.73)

    sourceDistanceH = easyqt.get_float(
        "Enter Distance to Source\n in the Horizontal [m]",
        title='Experimental Values',
        default_value=34.0)

    unFilterSize = easyqt.get_int("Enter Size for Uniform Filter [Pixels]\n" +
                                  "    (Enter 1 to NOT use the filter)",
                                  title='Experimental Values',
                                  default_value=1)

    searchRegion = easyqt.get_int(
        "Enter Size of Region for Searching\n the Peak [in Pixels]",
        title='Experimental Values',
        default_value=20)

    os.chdir(originalDir)

    # =============================================================================
    # %% Crop
    # =============================================================================

    idx4crop = [0, -1, 0, -1]

    [colorlimit, cmap] = wpu.plot_slide_colorbar(
        img,
        title='SELECT COLOR SCALE,\n' + 'Raw Image, No Crop',
        xlabel=r'x [$\mu m$ ]',
        ylabel=r'y [$\mu m$ ]',
        extent=wpu.extent_func(img, pixelSize) * 1e6)

    idx4crop = wpu.graphical_roi_idx(img,
                                     verbose=True,
                                     kargs4graph={
                                         'cmap': cmap,
                                         'vmin': colorlimit[0],
                                         'vmax': colorlimit[1]
                                     })

    wpu.print_blue("MESSAGE: idx for cropping")
    wpu.print_blue(idx4crop)

    # =============================================================================
    # %% Dark indexes
    # =============================================================================

    darkRegionSelctionFlag = easyqt.get_yes_or_no(
        'Do you want to select ' + 'region for dark calculation?\n' +
        'Press ESC to use [0, 20, 0, 20]')

    if darkRegionSelctionFlag:

        idx4cropDark = wpu.graphical_roi_idx(img,
                                             verbose=True,
                                             kargs4graph={
                                                 'cmap': cmap,
                                                 'vmin': colorlimit[0],
                                                 'vmax': colorlimit[1]
                                             })
    else:
        idx4cropDark = [0, 20, 0, 20]

    # dark_im = dxchange.read_tiff(listOfDataFiles[0])*0.0 + avgDark

    img = wpu.crop_matrix_at_indexes(img, idx4crop)

    # ==============================================================================
    # %% Harmonic Periods
    # ==============================================================================

    if pattern == 'Diagonal':
        period_harm_Vert = np.int(
            np.sqrt(2) * pixelSize / gratingPeriod * img.shape[0])
        period_harm_Horz = np.int(
            np.sqrt(2) * pixelSize / gratingPeriod * img.shape[1])
    elif pattern == 'Edge':
        period_harm_Vert = np.int(2 * pixelSize / gratingPeriod * img.shape[0])
        period_harm_Horz = np.int(2 * pixelSize / gratingPeriod * img.shape[1])

    # Obtain harmonic periods from images

    (period_harm_Vert,
     _) = wgi.exp_harm_period(img, [period_harm_Vert, period_harm_Horz],
                              harmonic_ij=['1', '0'],
                              searchRegion=40,
                              isFFT=False,
                              verbose=True)

    (_, period_harm_Horz) = wgi.exp_harm_period(
        img, [period_harm_Vert, period_harm_Horz],
        harmonic_ij=['0', '1'],
        searchRegion=40,
        isFFT=False,
        verbose=True)

    wpu.log_this('Input files: ' + samplefileName.rsplit('_', 1)[0] + '*.tif',
                 preffname=fname2save)
    wpu.log_this('\nNumber of files : ' + str(nfiles))
    wpu.log_this('Stride : ' + str(strideFile))
    wpu.log_this('Z distances is ' + zvec_from)

    if zvec_from == 'Calculated':
        wpu.log_this('Step zscan [mm] : {:.4g}'.format(step_z_scan * 1e3))
        wpu.log_this('Start point zscan [mm] : {:.4g}'.format(startDist * 1e3))

    wpu.log_this('Pixel Size [um] : {:.4g}'.format(pixelSize * 1e6))
    wpu.log_this('Grating Period [um] : {:.4g}'.format(gratingPeriod * 1e6))
    wpu.log_this('Grating Pattern : ' + pattern)
    wpu.log_this('Crop idxs : ' + str(idx4crop))
    wpu.log_this('Dark idxs : ' + str(idx4cropDark))

    wpu.log_this('Vertical Source Distance: ' + str(sourceDistanceV))
    wpu.log_this('Horizontal Source Distance: ' + str(sourceDistanceH))

    wpu.log_this('Uniform Filter Size : {:d}'.format(unFilterSize))

    wpu.log_this('Search Region : {:d}'.format(searchRegion))

    # =============================================================================
    # %% Calculate everything
    # =============================================================================

    # =============================================================================
    # %% multiprocessing
    # =============================================================================

    ncpus = cpu_count()

    wpu.print_blue("MESSAGE: %d cpu's available" % ncpus)

    tzero = time.time()

    p = Pool(ncpus - 5)

    indexes = range(len(listOfDataFiles))
    parameters = []

    for i in indexes:
        parameters.append([
            i, listOfDataFiles, zvec, idx4cropDark, idx4crop, period_harm_Vert,
            sourceDistanceV, period_harm_Horz, sourceDistanceH, searchRegion,
            unFilterSize
        ])

    res = p.map(_func, parameters)
    p.close()

    wpu.print_blue('MESSAGE: Time spent: {0:.3f} s'.format(time.time() -
                                                           tzero))
    '''
    res = []
    for i in range(len(listOfDataFiles)):
        res.append(_func(i))
    print(res)
    '''
    # =============================================================================
    # %% Sorting the data
    # =============================================================================

    contrastV = np.asarray([x[0] for x in res])
    contrastH = np.asarray([x[1] for x in res])

    p0 = np.asarray([x[2] for x in res])
    pv = np.asarray([x[3] for x in res])
    ph = np.asarray([x[4] for x in res])

    pattern_period_Vert_z = pixelSize / (pv[:, 0] - p0[:, 0]) * img.shape[0]
    pattern_period_Horz_z = pixelSize / (ph[:, 1] - p0[:, 1]) * img.shape[1]

    # =============================================================================
    # %% Save csv file
    # =============================================================================

    outputfname = wpu.get_unique_filename(fname2save, 'csv')

    wpu.save_csv_file(np.c_[zvec.T, contrastV.T, contrastH.T,
                            pattern_period_Vert_z.T, pattern_period_Horz_z.T],
                      outputfname,
                      headerList=[
                          'z [m]', 'Vert Contrast', 'Horz Contrast',
                          'Vert Period [m]', 'Horz Period [m]'
                      ])

    wpu.log_this('\nOutput file: ' + outputfname)

    # =============================================================================
    # %% Plot
    # =============================================================================

    # contrast vs z
    fig = plt.figure(figsize=(10, 7))
    plt.plot(zvec * 1e3, contrastV * 100, '-ko', label='Vert')
    plt.plot(zvec * 1e3, contrastH * 100, '-ro', label='Hor')
    plt.xlabel(r'Distance $z$  [mm]', fontsize=14)

    plt.ylabel(r'Visibility $\times$ 100 [%]', fontsize=14)
    plt.title('Visibility vs detector distance', fontsize=14, weight='bold')

    plt.legend(fontsize=14, loc=0)

    wpu.save_figs_with_idx(fname2save)
    plt.show(block=False)

    # =============================================================================
    # %% Plot Harmonic position and calculate source distance
    # =============================================================================
    #    from wavepytools.diag.coherence.fit_singleGratingCoherence_z_scan import fit_period_vs_z
    #xshi 20190719
    from fit_singleGratingCoherence_z_scan import fit_period_vs_z
    (sourceDistance_from_fit_V,
     patternPeriodFromData_V) = fit_period_vs_z(zvec,
                                                pattern_period_Vert_z,
                                                contrastV,
                                                direction='Vertical',
                                                threshold=.002,
                                                fname4graphs=fname2save)

    (sourceDistance_from_fit_H,
     patternPeriodFromData_H) = fit_period_vs_z(zvec,
                                                pattern_period_Horz_z,
                                                contrastH,
                                                direction='Horizontal',
                                                threshold=0.0005,
                                                fname4graphs=fname2save)
    if len(sys.argv) == 1:

        flist = easyqt.get_file_names("Pickle File to Plot")

        fname = flist[0]

        wavelength = hc/easyqt.get_float("Photon Energy [KeV]",
                                         title='Experimental Values',
                                         default_value=8.0)*1e-3

        grPeriod = easyqt.get_float("Enter CB Grating Period [um]",
                                    title='Experimental Values',
                                    default_value=4.8)*1e-6

        pattern = easyqt.get_choice(message='Select CB Grating Pattern',
                                    title='Experimental Values',
                                    choices=['Edge', 'Diagonal'])
#                                    choices=['Diagonal', 'Edge'])

        sourceDistance = easyqt.get_float("Enter Distance to Source [m]",
                                          title='Experimental Values',
                                          default_value=34)

    else:

        wavelength = hc/float(sys.argv[1])*1e-3

        grPeriod = float(sys.argv[2])*1e-6

        pattern = sys.argv[3]