示例#1
0
def take_image(global_PVs, params):

    log.info('  ***  *** taking a single image')

    nRow = global_PVs['Cam1SizeY_RBV'].get()
    nCol = global_PVs['Cam1SizeX_RBV'].get()

    image_size = nRow * nCol

    global_PVs['Cam1NumImages'].put(1, wait=True)

    global_PVs['Cam1TriggerMode'].put('Off', wait=True)
    wait_time_sec = int(params.exposure_time) + 5

    global_PVs['Cam1Acquire'].put(DetectorAcquire, wait=True, timeout=1000.0)
    time.sleep(0.1)
    if pv.wait_pv(global_PVs['Cam1Acquire'], DetectorIdle,
                  wait_time_sec) == False:  # adjust wait time
        global_PVs['Cam1Acquire'].put(DetectorIdle)

    # Get the image loaded in memory
    img_vect = global_PVs['Image'].get(count=image_size)
    img = np.reshape(img_vect, [nRow, nCol])

    pixelFormat = global_PVs['Cam1PixelFormat_RBV'].get(as_string=True)
    if (pixelFormat == "Mono16"):
        pixel_f = 16
    elif (pixelFormat == "Mono8"):
        pixel_f = 8
    else:
        log.error('  ***  *** bit %s format not supported' % pixelFormat)
        exit()
    img_uint = np.mod(img, 2**pixel_f)

    return img_uint
示例#2
0
def adjust(what, params):

    global_PVs = pv.init_general_PVs(params)

    try:
        detector_sn = global_PVs['Cam1SerialNumber'].get()
        if ((detector_sn == None) or (detector_sn == 'Unknown')):
            log.error('*** The detector with EPICS IOC prefix %s is down' %
                      params.detector_prefix)
            log.error('  *** Failed!')
        else:
            log.info('*** The detector with EPICS IOC prefix %s and serial number %s is on' \
                        % (params.detector_prefix, detector_sn))

            if (what == 'resolution'):
                detector.init(global_PVs, params)
                detector.set(global_PVs, params)
                dark_field, white_field = detector.take_dark_and_white(
                    global_PVs, params)
                find_resolution(params,
                                dark_field,
                                white_field,
                                angle_shift=-0.7)
                config.update_sphere(params)
            else:
                if (params.image_pixel_size == None):
                    # resolution must be measured at least once
                    log.error(
                        '  *** Detector resolution is not determined. Please run adjust resolution first!'
                    )
                    time.sleep(
                        2
                    )  # to avoid a calling callback function/epics.ca.ChannelAccessException
                    exit()
                else:
                    dark_field, white_field = detector.take_dark_and_white(
                        global_PVs, params)
                    if (what == 'focus'):
                        adjust_focus(params)
                    if (what == 'center'):
                        adjust_center(params, dark_field, white_field)
                    if (what == 'roll'):
                        adjust_roll(params,
                                    dark_field,
                                    white_field,
                                    angle_shift=-0.7)
                    if (what == 'pitch'):
                        adjust_pitch(params,
                                     dark_field,
                                     white_field,
                                     angle_shift=-0.7)
                    if (what == 'roll') or (what == 'pitch'):
                        # align center again for higher accuracy
                        adjust_center(params, dark_field, white_field)

                    config.update_sphere(params)

    except KeyError:
        log.error('  *** Some PV assignment failed!')
        pass
示例#3
0
def center_of_mass(image):

    threshold_value = filters.threshold_otsu(image)
    log.info("  ***  *** threshold_value: %f" % (threshold_value))
    labeled_foreground = (image < threshold_value).astype(int)
    properties = regionprops(labeled_foreground, image)
    return properties[0].weighted_centroid
示例#4
0
def take_dark_and_white(global_PVs, params):
    pv.close_shutters(global_PVs, params)
    log.info('  ***  *** acquire dark')
    dark_field = take_image(global_PVs, params)
    # plot(dark_field)

    pv.open_shutters(global_PVs, params)
    pv.move_sample_out(global_PVs, params)
    log.info('  ***  *** acquire white')
    white_field = take_image(global_PVs, params)
    # plot(white_field)

    pv.move_sample_in(global_PVs, params)

    return dark_field, white_field
示例#5
0
def check_center(params, white_field, dark_field):

    global_PVs = pv.init_general_PVs(params)

    log.warning('  *** CHECK center of mass for the centered sphere')

    log.info('  *** moving rotary stage to %f deg position ***' % float(0))
    global_PVs["Rotation"].put(float(0), wait=True, timeout=600.0)
    log.info('  *** acquire sphere at %f deg position ***' % float(0))

    sphere_0 = util.normalize(detector.take_image(global_PVs, params),
                              white_field, dark_field)
    cmass_0 = util.center_of_mass(sphere_0)
    log.warning(
        '  *** center of mass for the centered sphere at 0 deg: [%f,%f] ***' %
        (cmass_0[1], cmass_0[0]))
示例#6
0
def normalize(arr, flat, dark, cutoff=None, out=None):
    """
    Normalize raw projection data using the flat and dark field projections.

    Parameters
    ----------
    arr : ndarray
        2D of projections.
    flat : ndarray
        2D flat field data.
    dark : ndarray
        2D dark field data.
    cutoff : float, optional
        Permitted maximum vaue for the normalized data.
    out : ndarray, optional
        Output array for result. If same as arr,
        process will be done in-place.

    Returns
    -------
    ndarray
        Normalized 2D tomographic data.
    """
    arr = as_float32(arr)
    l = np.float32(1e-5)
    log.info('  ***  *** image size: [%d, %d]' %
             (flat.shape[0], flat.shape[1]))
    # flat = np.mean(flat, axis=0, dtype=np.float32)
    # dark = np.mean(dark, axis=0, dtype=np.float32)
    flat = flat.astype('float32')
    dark = dark.astype('float32')

    denom = ne.evaluate('flat')
    # denom = ne.evaluate('flat-dark')
    ne.evaluate('where(denom<l,l,denom)', out=denom)
    out = ne.evaluate('arr', out=out)
    # out = ne.evaluate('arr-dark', out=out)
    ne.evaluate('out/denom', out=out, truediv=True)
    if cutoff is not None:
        cutoff = np.float32(cutoff)
        ne.evaluate('where(out>cutoff,cutoff,out)', out=out)
    return out
示例#7
0
def show_configs(args):
    """Log all values set in the args namespace.

    Arguments are grouped according to their section and logged alphabetically
    using the DEBUG log level thus --verbose is required.
    """
    args = args.__dict__

    log.warning('adjust status start')
    for section, name in zip(SECTIONS, NICE_NAMES):
        entries = sorted((k for k in args.keys() if k.replace('_', '-') in SECTIONS[section]))

        # print('show_configs', section, name, entries)
        if entries:
            log.info(name)

            for entry in entries:
                value = args[entry] if args[entry] is not None else "-"
                log.info("  {:<16} {}".format(entry, value))

    log.warning('adjust status end')
示例#8
0
def set(global_PVs, params):

    if (params.detector_prefix == '2bmbSP1:'):
        log.info(' ')
        log.info('  *** setup FLIR camera')

        global_PVs['Cam1Acquire'].put(DetectorIdle)
        pv.wait_pv(global_PVs['Cam1Acquire'], DetectorIdle, 2)

        global_PVs['Cam1TriggerMode'].put('Off', wait=True)
        global_PVs['Cam1TriggerSource'].put('Line2', wait=True)
        global_PVs['Cam1TriggerOverlap'].put('ReadOut', wait=True)
        global_PVs['Cam1ExposureMode'].put('Timed', wait=True)
        global_PVs['Cam1TriggerSelector'].put('FrameStart', wait=True)
        global_PVs['Cam1TriggerActivation'].put('RisingEdge', wait=True)

        global_PVs['Cam1ImageMode'].put('Multiple')
        global_PVs['Cam1ArrayCallbacks'].put('Enable')
        global_PVs['Cam1FrameRateOnOff'].put(0)
        global_PVs['Cam1AcquireTimeAuto'].put('Off')

        global_PVs['Cam1AcquireTime'].put(float(params.exposure_time))

        wait_time_sec = int(params.exposure_time) + 5

        global_PVs['Cam1TriggerMode'].put('On', wait=True)
        log.info('  *** setup FLIR camera: Done!')

    else:
        log.error('Detector %s is not supported' % params.detector_prefix)
        return
示例#9
0
def close_shutters(global_PVs, params):

    log.info(' ')
    log.info('  *** close_shutters')

    global_PVs['ShutterClose'].put(params.shutter_close_value, wait=True)
    wait_pv(global_PVs['ShutterStatus'], params.shutter_status_close_value)
    log.info('  *** close_shutter: Done!')
示例#10
0
def open_shutters(global_PVs, params):

    log.info(' ')
    log.info('  *** open_shutters')

    global_PVs['ShutterOpen'].put(str(params.shutter_open_value), wait=True)
    wait_pv(global_PVs['ShutterStatus'], params.shutter_status_open_value)
    log.info('  *** open_shutter: Done!')
示例#11
0
def adjust_focus(params):

    global_PVs = pv.init_general_PVs(params)

    step = 1

    direction = 1
    max_std = 0
    three_std = np.ones(3) * 2**16
    cnt = 0
    decrease_step = False
    while (step > 0.01):
        initpos = global_PVs['Focus'].get()
        curpos = initpos + step * direction
        global_PVs['Focus'].put(curpos, wait=True, timeout=600.0)
        img = detector.take_image(global_PVs, params)
        cur_std = np.std(img)
        log.info('  ***   *** Positon: %f Standard deviation: %f ' %
                 (curpos, cur_std))
        if (cur_std > max_std):  # store max std
            max_std = cur_std
        three_std[np.mod(cnt,
                         3)] = cur_std  # store std for 3 last measurements
        if (np.sum(three_std < max_std) == 3):  # pass a peak
            direction = -direction
            if (decrease_step):  # decrease focusing motor step
                step /= 2
            else:  #do not decrease step for the first direction change
                decrease_step = True
            three_std = np.ones(3) * 2**16
            max_std = 0
            log.warning('  *** change direction and step to %f' % (step))
        cnt += 1

    log.warning('  *** Focusing done')

    return
示例#12
0
def move_sample_in(global_PVs, params):

    axis = params.flat_field_axis

    log.info('move_sample_in axis: %s', axis)
    if axis in ('horizontal', 'both'):
        position = params.sample_in_x
        log.info('      *** *** Move Sample X in at: %f' % position)
        global_PVs['SampleX'].put(position, wait=True)

    if axis in ('vertical', 'both'):
        position = params.sample_in_y
        log.info('      *** *** Move Sample Y in at: %f' % position)
        global_PVs['SampleY'].put(position, wait=True)
示例#13
0
def move_center(params, cmass_0, x, y):

    global_PVs = pv.init_general_PVs(params)

    log.info('  *** moving sample top X to the rotation center ***')
    global_PVs["SampleXCent"].put(global_PVs["SampleXCent"].get() +
                                  x * params.image_pixel_size / 1000,
                                  wait=True,
                                  timeout=5.0)
    log.info('  *** moving sample top Z to the rotation center ***')
    global_PVs["SampleZCent"].put(global_PVs["SampleZCent"].get() +
                                  y * params.image_pixel_size / 1000,
                                  wait=True,
                                  timeout=5.0)
    log.info('  *** moving rotation center to the detector center ***')
    global_PVs["SampleX"].put(
        global_PVs["SampleX"].get() -
        (cmass_0[1] - x - global_PVs['Cam1SizeX'].get() / 2) *
        params.image_pixel_size / 1000,
        wait=True,
        timeout=600.0)
示例#14
0
def init(global_PVs, params):
    if (params.detector_prefix == '2bmbSP1:'):
        log.info(' ')
        log.info('  *** init FLIR camera')
        log.info('  *** *** set detector to idle')
        global_PVs['Cam1Acquire'].put(DetectorIdle)
        pv.wait_pv(global_PVs['Cam1Acquire'], DetectorIdle, 2)
        log.info('  *** *** set detector to idle:  Done')
        time.sleep(2)
        log.info('  *** *** set trigger mode to Off')
        global_PVs['Cam1TriggerMode'].put('Off', wait=True)  #
        log.info('  *** *** set trigger mode to Off: done')
        time.sleep(7)
        log.info('  *** *** set image mode to single')
        global_PVs['Cam1ImageMode'].put(
            'Single', wait=True
        )  # here is where it crashes with (ValueError: invalid literal for int() with base 0: 'Single') Added 7 s delay before
        log.info('  *** *** set image mode to single: done')
        log.info('  *** *** set cam display to 1')
        global_PVs['Cam1Display'].put(1)
        log.info('  *** *** set cam display to 1: done')
        log.info('  *** *** set cam acquire')
        global_PVs['Cam1Acquire'].put(DetectorAcquire)
        pv.wait_pv(global_PVs['Cam1Acquire'], DetectorAcquire, 2)
        log.info('  *** *** set cam acquire: done')
        log.info('  *** init FLIR camera: Done!')
    else:
        log.error('Detector %s is not supported' % params.detector_prefix)
        return
示例#15
0
def adjust_roll(params, dark_field, white_field, angle_shift):

    # angle_shift is the correction that is needed to apply to the rotation axis position
    # to align the Z stage on top of the rotary stage with the beam

    global_PVs = pv.init_general_PVs(params)

    log.warning(' *** Adjusting roll ***')
    log.info('  *** moving rotary stage to %f deg position ***' %
             float(0 + angle_shift))
    global_PVs["Rotation"].put(float(0 + angle_shift),
                               wait=True,
                               timeout=600.0)
    log.info('  *** moving sphere to the detector border ***')
    global_PVs["SampleXCent"].put(
        global_PVs["SampleXCent"].get() +
        global_PVs['Cam1SizeX'].get() / 2 * params.image_pixel_size / 1000 -
        ((SPHERE_DIAMETER / 2) + GAP),
        wait=True,
        timeout=600.0)
    log.info('  *** acquire sphere at %f deg position ***' %
             float(0 + angle_shift))
    sphere_0 = util.normalize(detector.take_image(global_PVs, params),
                              white_field, dark_field)
    log.info('  *** moving rotary stage to %f deg position ***' %
             float(180 + angle_shift))
    global_PVs["Rotation"].put(float(180 + angle_shift),
                               wait=True,
                               timeout=600.0)
    log.info('  *** acquire sphere at %f deg position ***' %
             float(180 + angle_shift))
    sphere_180 = util.normalize(detector.take_image(global_PVs, params),
                                white_field, dark_field)

    cmass_0 = util.center_of_mass(sphere_0)
    cmass_180 = util.center_of_mass(sphere_180)
    log.info('  *** center of mass for the sphere at 0 deg (%f,%f) ***' %
             (cmass_0[1], cmass_0[0]))
    log.info('  *** center of mass for the sphere at 180 deg (%f,%f) ***' %
             (cmass_180[1], cmass_180[0]))

    roll = np.rad2deg(
        np.arctan((cmass_180[0] - cmass_0[0]) / (cmass_180[1] - cmass_0[1])))
    log.warning('  *** found roll error: %f' % roll)

    log.info('  *** moving rotary stage to %f deg position ***' %
             float(0 + angle_shift))
    global_PVs["Rotation"].put(float(0 + angle_shift),
                               wait=True,
                               timeout=600.0)
    log.info('  *** moving sphere back to the detector center ***')
    global_PVs["SampleXCent"].put(
        global_PVs["SampleXCent"].get() -
        (global_PVs['Cam1SizeX'].get() / 2 * params.image_pixel_size / 1000 -
         ((SPHERE_DIAMETER / 2) + GAP)),
        wait=True,
        timeout=600.0)

    log.info('  *** find shifts resulting by the roll change ***')
    log.info('  *** acquire sphere at the current roll position ***')
    sphere_0 = util.normalize(detector.take_image(global_PVs, params),
                              white_field, dark_field)

    ang = roll / 2  # if roll is too big then ang should be decreased to keep the sphere in the field of view
    log.info('  *** acquire sphere after testing roll change %f ***' %
             float(global_PVs["SampleRoll"].get() + ang))
    global_PVs["SampleRoll"].put(global_PVs["SampleRoll"].get() + ang,
                                 wait=True,
                                 timeout=600.0)
    sphere_1 = util.normalize(detector.take_image(global_PVs, params),
                              white_field, dark_field)

    shift0 = register_translation(sphere_1, sphere_0, 100)[0][1]
    shift1 = shift0 * np.sin(roll) * (np.cos(roll) * 1 / np.tan(ang) +
                                      np.sin(roll))
    log.info(
        '  *** the testing roll change corresponds to %f shift in x, calculated resulting roll change gives %f shift in x ***'
        % (shift0, shift1))
    log.warning('  *** change roll to %f ***' %
                float(global_PVs["SampleRoll"].get() + roll - ang))
    global_PVs["SampleRoll"].put(global_PVs["SampleRoll"].get() + roll - ang,
                                 wait=True,
                                 timeout=600.0)
    log.info('  *** moving sphere to the detector center ***')
    global_PVs["SampleX"].put(global_PVs["SampleX"].get() -
                              shift1 * params.image_pixel_size / 1000,
                              wait=True,
                              timeout=600.0)

    log.info('  *** TEST: acquire sphere at %f deg position ***' %
             float(0 + angle_shift))
    sphere_0 = util.normalize(detector.take_image(global_PVs, params),
                              white_field, dark_field)
    cmass_0 = util.center_of_mass(sphere_0)
    log.info('  *** TEST: center of mass for the sphere at 0 deg (%f,%f) ***' %
             (cmass_0[1], cmass_0[0]))
示例#16
0
def adjust_pitch(params, dark_field, white_field, angle_shift):

    global_PVs = pv.init_general_PVs(params)

    log.warning(' *** Adjusting pitch ***')
    log.info(
        '  *** acquire sphere after moving it along the beam axis by 1mm ***')
    global_PVs["SampleZCent"].put(global_PVs["SampleZCent"].get() - 1.0,
                                  wait=True,
                                  timeout=600.0)

    log.info('  *** moving rotary stage to %f deg position ***' %
             float(0 + angle_shift))
    global_PVs["Rotation"].put(float(0 + angle_shift),
                               wait=True,
                               timeout=600.0)
    log.info('  *** acquire sphere at %f deg position ***' %
             float(0 + angle_shift))
    sphere_0 = util.normalize(detector.take_image(global_PVs, params),
                              white_field, dark_field)

    log.info('  *** moving rotary stage to %f deg position ***' %
             float(0 + angle_shift))
    global_PVs["Rotation"].put(float(180 + angle_shift),
                               wait=True,
                               timeout=600.0)
    log.info('  *** acquire sphere at %f deg position ***' %
             float(180 + angle_shift))
    sphere_180 = util.normalize(detector.take_image(global_PVs, params),
                                white_field, dark_field)

    cmass_0 = util.center_of_mass(sphere_0)
    cmass_180 = util.center_of_mass(sphere_180)
    log.info('  *** center of mass for the initial sphere (%f,%f) ***' %
             (cmass_0[1], cmass_0[0]))
    log.info('  *** center of mass for the shifted sphere (%f,%f) ***' %
             (cmass_180[1], cmass_180[0]))
    pitch = np.rad2deg(
        np.arctan((cmass_180[0] - cmass_0[0]) * params.image_pixel_size /
                  1000 / 2.0))
    log.warning('  *** found pitch error: %f' % pitch)
    log.info('  *** acquire sphere back along the beam axis by -1mm ***')
    global_PVs["SampleZCent"].put(global_PVs["SampleZCent"].get() + 1.0,
                                  wait=True,
                                  timeout=600.0)
    log.warning('  *** change pitch to %f ***' %
                float(global_PVs["SamplePitch"].get() - pitch))
    global_PVs["SamplePitch"].put(global_PVs["SamplePitch"].get() - pitch,
                                  wait=True,
                                  timeout=600.0)
    global_PVs["Rotation"].put(float(0 + angle_shift),
                               wait=True,
                               timeout=600.0)

    log.info('  *** TEST: acquire sphere at %f deg position ***' %
             float(0 + angle_shift))
    sphere_0 = util.normalize(detector.take_image(global_PVs, params),
                              white_field, dark_field)
    cmass_0 = util.center_of_mass(sphere_0)
    log.info('  *** TEST: center of mass for the sphere at 0 deg (%f,%f) ***' %
             (cmass_0[1], cmass_0[0]))
示例#17
0
def find_resolution(params, dark_field, white_field, angle_shift):

    global_PVs = pv.init_general_PVs(params)

    log.warning(' *** Find resolution ***')
    log.info('  *** moving rotary stage to %f deg position ***' %
             float(0 + angle_shift))
    global_PVs["Rotation"].put(float(0 + angle_shift),
                               wait=True,
                               timeout=600.0)
    log.info('  *** First image at X: %f mm' % (params.sample_in_x))
    log.info('  *** acquire first image')

    sphere_0 = util.normalize(detector.take_image(global_PVs, params),
                              white_field, dark_field)

    second_image_x_position = params.sample_in_x + params.off_axis_position
    log.info('  *** Second image at X: %f mm' % (second_image_x_position))
    global_PVs["SampleX"].put(second_image_x_position,
                              wait=True,
                              timeout=600.0)
    log.info('  *** acquire second image')
    sphere_1 = util.normalize(detector.take_image(global_PVs, params),
                              white_field, dark_field)

    log.info('  *** moving X stage back to %f mm position' %
             (params.sample_in_x))
    pv.move_sample_in(global_PVs, params)

    shift = register_translation(sphere_0, sphere_1, 100)
    log.info('  *** shift X: %f, Y: %f' % (shift[0][1], shift[0][0]))
    image_pixel_size = abs(params.off_axis_position) / np.linalg.norm(
        shift[0]) * 1000.0

    log.warning('  *** found resolution %f um/pixel' % (image_pixel_size))
    params.image_pixel_size = image_pixel_size

    global_PVs['ImagePixelSize'].put(params.image_pixel_size, wait=True)
示例#18
0
def init_general_PVs(params):

    global_PVs = {}

    global_PVs['ShutterOpen'] = PV(params.shutter_open_pv_name + '.VAL')
    global_PVs['ShutterClose'] = PV(params.shutter_close_pv_name + '.VAL')
    global_PVs['ShutterStatus'] = PV(params.shutter_status_pv_name + '.VAL')

    global_PVs['SampleX'] = PV(params.sample_x_pv_name + '.VAL')
    global_PVs['SampleXSet'] = PV(params.sample_x_pv_name + '.SET')
    global_PVs['SampleY'] = PV(params.sample_y_pv_name + '.VAL')
    global_PVs['SampleYSet'] = PV(params.sample_y_pv_name + '.SET')

    global_PVs['Rotation'] = PV(params.rotation_pv_name + '.VAL')
    global_PVs['RotationRBV'] = PV(params.rotation_pv_name + '.RBV')
    global_PVs['RotationCnen'] = PV(params.rotation_pv_name + '.CNEN')
    global_PVs['RotationAccl'] = PV(params.rotation_pv_name + '.ACCL')
    global_PVs['RotationStop'] = PV(params.rotation_pv_name + '.STOP')
    global_PVs['RotationSet'] = PV(params.rotation_pv_name + '.SET')
    global_PVs['RotationVelo'] = PV(params.rotation_pv_name + '.VELO')

    global_PVs['SampleXCent'] = PV(params.sample_x_center_pv_name + '.VAL')
    global_PVs['SampleZCent'] = PV(params.sample_z_center_pv_name + '.VAL')
    global_PVs['SamplePitch'] = PV(params.sample_pitch_pv_name + '.VAL')
    global_PVs['SampleRoll'] = PV(params.sample_roll_pv_name + '.VAL')

    global_PVs['Focus'] = PV(params.focus_pv_name + '.VAL')

    global_PVs['ImagePixelSize'] = PV(params.image_pixel_size_pv_name + '.VAL')

    # detector pv's
    camera_prefix = params.detector_prefix + 'cam1:'

    global_PVs['CamManufacturer'] = PV(camera_prefix + 'Manufacturer_RBV')
    global_PVs['CamModel'] = PV(camera_prefix + 'Model_RBV')
    global_PVs['Cam1SerialNumber'] = PV(camera_prefix + 'SerialNumber_RBV')
    global_PVs['Cam1ImageMode'] = PV(camera_prefix + 'ImageMode')
    global_PVs['Cam1ArrayCallbacks'] = PV(camera_prefix + 'ArrayCallbacks')
    global_PVs['Cam1AcquirePeriod'] = PV(camera_prefix + 'AcquirePeriod')
    global_PVs['Cam1SoftwareTrigger'] = PV(camera_prefix + 'SoftwareTrigger')
    global_PVs['Cam1AcquireTime'] = PV(camera_prefix + 'AcquireTime')
    global_PVs['Cam1FrameType'] = PV(camera_prefix + 'FrameType')
    global_PVs['Cam1AttributeFile'] = PV(camera_prefix + 'NDAttributesFile')

    global_PVs['Cam1SizeX'] = PV(camera_prefix + 'SizeX')
    global_PVs['Cam1SizeY'] = PV(camera_prefix + 'SizeY')
    global_PVs['Cam1NumImages'] = PV(camera_prefix + 'NumImages')
    global_PVs['Cam1TriggerMode'] = PV(camera_prefix + 'TriggerMode')
    global_PVs['Cam1Acquire'] = PV(camera_prefix + 'Acquire')

    global_PVs['Cam1SizeX_RBV'] = PV(camera_prefix + 'SizeX_RBV')
    global_PVs['Cam1SizeY_RBV'] = PV(camera_prefix + 'SizeY_RBV')

    global_PVs['Cam1MaxSizeX_RBV'] = PV(camera_prefix + 'MaxSizeX_RBV')
    global_PVs['Cam1MaxSizeY_RBV'] = PV(camera_prefix + 'MaxSizeY_RBV')
    global_PVs['Cam1PixelFormat_RBV'] = PV(camera_prefix + 'PixelFormat_RBV')

    image_prefix = params.detector_prefix + 'image1:'
    global_PVs['Image'] = PV(image_prefix + 'ArrayData')
    global_PVs['Cam1Display'] = PV(image_prefix + 'EnableCallbacks')

    manufacturer = global_PVs['CamManufacturer'].get(as_string=True)
    model = global_PVs['CamModel'].get(as_string=True)

    if model == 'Oryx ORX-10G-51S5M':
        log.info('Detector %s model %s:' % (manufacturer, model))
        global_PVs['Cam1AcquireTimeAuto'] = PV(params.detector_prefix +
                                               'AcquireTimeAuto')
        global_PVs['Cam1FrameRateOnOff'] = PV(params.detector_prefix +
                                              'FrameRateEnable')

        global_PVs['Cam1TriggerSource'] = PV(params.detector_prefix +
                                             'TriggerSource')
        global_PVs['Cam1TriggerOverlap'] = PV(params.detector_prefix +
                                              'TriggerOverlap')
        global_PVs['Cam1ExposureMode'] = PV(params.detector_prefix +
                                            'ExposureMode')
        global_PVs['Cam1TriggerSelector'] = PV(params.detector_prefix +
                                               'TriggerSelector')
        global_PVs['Cam1TriggerActivation'] = PV(params.detector_prefix +
                                                 'TriggerActivation')

    else:
        log.error('Detector %s model %s is not supported' %
                  (manufacturer, model))
        return None

    return global_PVs
示例#19
0
def adjust_center(params, dark_field, white_field):

    global_PVs = pv.init_general_PVs(params)

    log.warning(' *** Adjusting center ***')
    for ang in [params.adjust_center_angle_1, params.adjust_center_angle_2]:
        log.warning('  *** take 3 spheres angular %f deg ***' % float(ang))

        #sphere 0
        log.info('  *** sphere 0')
        log.info('  ***  *** moving rotary stage to %f deg position ***' %
                 float(0))
        global_PVs["Rotation"].put(float(0), wait=True, timeout=600.0)
        log.error('  ***  *** acquire sphere at %f deg position ***' %
                  float(0))
        sphere_0 = util.normalize(detector.take_image(global_PVs, params),
                                  white_field, dark_field)

        #sphere 1
        log.info('  *** sphere 1')
        log.info('  ***  *** moving rotary stage to %f deg position ***' %
                 float(ang))
        global_PVs["Rotation"].put(float(ang), wait=True, timeout=600.0)
        log.error('  ***  *** acquire sphere at %f deg position ***' %
                  float(ang))
        sphere_1 = util.normalize(detector.take_image(global_PVs, params),
                                  white_field, dark_field)

        #sphere 2
        log.info('  *** sphere 2')
        log.info('  ***  *** moving rotary stage to %f deg position ***' %
                 float(2 * ang))
        global_PVs["Rotation"].put(float(2 * ang), wait=True, timeout=600.0)
        log.error('  ***  *** acquire sphere at %f deg position ***' %
                  float(2 * ang))
        sphere_2 = util.normalize(detector.take_image(global_PVs, params),
                                  white_field, dark_field)

        # find shifts
        shift0 = register_translation(sphere_1, sphere_0, 100)[0][1]
        shift1 = register_translation(sphere_2, sphere_1, 100)[0][1]
        a = ang * np.pi / 180
        # x=-(1/4) (d1+d2-2 d1 Cos[a]) Csc[a/2]^2,
        x = -(1 / 4) * (shift0 + shift1 - 2 * shift0 * np.cos(a)) * 1 / np.sin(
            a / 2)**2
        # r = 1/2 Csc[a/2]^2 Csc[a] Sqrt[(d1^2+d2^2-2 d1 d2 Cos[a]) Sin[a/2]^2]
        r = 1 / 2 * 1 / np.sin(a / 2)**2 * 1 / np.sin(a) * np.sqrt(
            np.abs((shift0**2 + shift1**2 - 2 * shift0 * shift1 * np.cos(a)) *
                   np.sin(a / 2)**2))
        # g = ArcCos[((-d1-d2+2 d1 Cos[a]) Sin[a])/(2 Sqrt[(d1^2+d2^2-2 d1 d2 Cos[a]) Sin[a/2]^2])]
        g = np.arccos(
            ((-shift0 - shift1 + 2 * shift0 * np.cos(a)) * np.sin(a)) /
            (2 * np.sqrt(
                np.abs(
                    (shift0**2 + shift1**2 - 2 * shift0 * shift1 * np.cos(a)) *
                    np.sin(a / 2)**2))))
        y = r * np.sin(g) * np.sign(shift0)

        # find center of mass
        cmass_0 = util.center_of_mass(sphere_0)

        log.info('  ')
        log.info(
            '  *** position of the initial sphere wrt to the rotation center (%f,%f) ***'
            % (x, y))
        log.info('  *** center of mass for the initial sphere (%f,%f) ***' %
                 (cmass_0[1], cmass_0[0]))
        log.info(
            '  *** moving sphere to the position of the rotation center ***')

        if (params.ask):
            if util.yes_or_no('   *** Yes or No'):
                move_center(params, cmass_0, x, y)
                check_center(params, white_field, dark_field)
            else:
                log.warning(' No motion ')
                exit()

        else:
            move_center(params, cmass_0, x, y)
            check_center(params, white_field, dark_field)