baslerCtrl.hpp

Go to the documentation of this file.

/** \file baslerCtrl.hpp
 * \brief The MagAO-X basler camera controller.
 *
 * \author Jared R. Males (jaredmales@gmail.com)
 *
 * \ingroup baslerCtrl_files
 */
 
#ifndef baslerCtrl_hpp
#define baslerCtrl_hpp
 
#include <pylon/PylonIncludes.h>
#include <pylon/PixelData.h>
#include <pylon/GrabResultData.h>
#include <pylon/usb/BaslerUsbInstantCamera.h>
#include <pylon/usb/_BaslerUsbCameraParams.h>
#include <GenApi/IFloat.h>
 
typedef Pylon::CBaslerUsbInstantCamera Camera_t;
typedef int16_t                        pixelT;
 
using namespace Basler_UsbCameraParams;
 
using namespace Pylon;
 
// #include <ImageStruct.h>
#include <ImageStreamIO/ImageStreamIO.h>
 
#include "../../libMagAOX/libMagAOX.hpp" //Note this is included on command line to trigger pch
#include "../../magaox_git_version.h"
 
namespace MagAOX
{
namespace app
{
 
/** \defgroup baslerCtrl Basler USB3 Camera
 * \brief Control of a Basler USB3 Camera
 *
 * <a href="../handbook/operating/software/apps/baslerCtrl.html">Application Documentation</a>
 *
 * \ingroup apps
 *
 */
 
/** \defgroup baslerCtrl_files Basler USB3 Camera Files
 * \ingroup baslerCtrl
 */
 
/** MagAO-X application to control a Basler USB3 Camera
 *
 * \ingroup baslerCtrl
 *
 */
class baslerCtrl : public MagAOXApp<>,
                   public dev::stdCamera<baslerCtrl>,
                   public dev::frameGrabber<baslerCtrl>,
                   public dev::telemeter<baslerCtrl>
{
 
    typedef dev::stdCamera<baslerCtrl>    stdCameraT;
    typedef dev::frameGrabber<baslerCtrl> frameGrabberT;
    typedef dev::telemeter<baslerCtrl>    telemeterT;
 
    friend class dev::stdCamera<baslerCtrl>;
    friend class dev::frameGrabber<baslerCtrl>;
    friend class dev::telemeter<baslerCtrl>;
 
  public:
    /** \name app::dev Configurations
     *@{
     */
    static constexpr bool c_stdCamera_tempControl =
        false; ///< app::dev config to tell stdCamera to not expose temperature controls
 
    static constexpr bool c_stdCamera_temp = true; ///< app::dev config to tell stdCamera to expose temperature
 
    static constexpr bool c_stdCamera_readoutSpeed =
        false; ///< app::dev config to tell stdCamera not to  expose readout speed controls
 
    static constexpr bool c_stdCamera_vShiftSpeed =
        false; ///< app:dev config to tell stdCamera not to expose vertical shift speed control
 
    static constexpr bool c_stdCamera_emGain =
        false; ///< app::dev config to tell stdCamera to not expose EM gain controls
 
    static constexpr bool c_stdCamera_exptimeCtrl =
        true; ///< app::dev config to tell stdCamera to expose exposure time controls
 
    static constexpr bool c_stdCamera_fpsCtrl = true; ///< app::dev config to tell stdCamera to expose FPS controls
 
    static constexpr bool c_stdCamera_fps =
        true; ///< app::dev config to tell stdCamera not to expose FPS status (ignored since fpsCtrl=true)
 
    static constexpr bool c_stdCamera_synchro =
        false; ///< app::dev config to tell stdCamera to not expose synchro mode controls
 
    static constexpr bool c_stdCamera_usesModes =
        false; ///< app:dev config to tell stdCamera not to expose mode controls
 
    static constexpr bool c_stdCamera_usesROI = true; ///< app:dev config to tell stdCamera to expose ROI controls
 
    static constexpr bool c_stdCamera_cropMode =
        false; ///< app:dev config to tell stdCamera not to expose Crop Mode controls
 
    static constexpr bool c_stdCamera_hasShutter =
        false; ///< app:dev config to tell stdCamera to expose shutter controls
 
    static constexpr bool c_stdCamera_usesStateString =
        true; ///< app::dev confg to tell stdCamera to expose the state string property
 
    static constexpr bool c_frameGrabber_flippable =
        true; ///< app:dev config to tell framegrabber that this camera can be flipped
 
    ///@}
 
  protected:
    /** \name configurable parameters
     *@{
     */
    std::string m_serialNumber; ///< The camera's identifying serial number
 
    int m_bits{ 10 }; ///< The number of bits used by the camera.
 
    ///@}
 
    /** \name binning allowed values
     * @{
     */
    std::vector<int> m_binXs; ///< The allowed values of binning in X (horizontal)
    std::vector<int> m_binYs; ///< The allowed values of binning in Y (vertical)
 
    std::vector<int> m_incXs; ///< The allowed increment in X for each X-binning
 
    std::vector<int> m_minWs; ///< The minimum value of the width for each X-binning
    std::vector<int> m_incWs; ///< The minimum value of the width for each X-binning
    std::vector<int> m_maxWs; ///< The minimum value of the width for each X-binning
 
    std::vector<int> m_incYs; ///< The allowed increment in Y for each Y-binning
 
    std::vector<int> m_minHs; ///< The minimum value of the height for each Y-binning
    std::vector<int> m_incHs; ///< The minimum value of the height for each Y-binning
    std::vector<int> m_maxHs; ///< The minimum value of the height for each Y-binning
 
    ///@}
 
    CBaslerUsbInstantCamera *m_camera{ nullptr }; ///< The library camera handle
    CGrabResultPtr           ptrGrabResult;       ///< The result of an attempt to grab an image
 
    mx::sigproc::circularBufferIndex<float, int32_t> m_tempHist;
 
  public:
    /// Default c'tor
    baslerCtrl();
 
    /// Destructor
    ~baslerCtrl() noexcept;
 
    /// Setup the configuration system (called by MagAOXApp::setup())
    virtual void setupConfig();
 
    /// Implementation of loadConfig logic, separated for testing.
    /** This is called by loadConfig().
     */
    int loadConfigImpl( mx::app::appConfigurator &_config /**< [in] an application configuration
                                                                    from which to load values*/
    );
 
    /// load the configuration system results (called by MagAOXApp::setup())
    virtual void loadConfig();
 
    /// Startup functions
    /** Sets up the INDI vars.
     *
     */
    virtual int appStartup();
 
    /// Implementation of the FSM for the Siglent SDG
    virtual int appLogic();
 
    /// Do any needed shutdown tasks.  Currently nothing in this app.
    virtual int appShutdown();
 
    int connect();
 
    int configureAcquisition();
    int startAcquisition();
    int acquireAndCheckValid();
    int loadImageIntoStream( void *dest );
    int reconfig();
 
  protected:
    /// Get the current detector temperature
    /**
     * \returns 0 on success
     * \returns -1 on an error.
     */
    int getTemp();
 
    /// Get the current exposure time
    /**
     * \returns 0 on success
     * \returns -1 on an error.
     */
    int getExpTime();
 
    /// Get the current framerate
    /**
     * \returns 0 on success
     * \returns -1 on an error.
     */
    int getFPS();
 
    float fps();
 
    /** \name stdCamera Interface
     *
     * @{
     */
 
    /// Set defaults for a power on state.
    /**
     * \returns 0 on success
     * \returns -1 on error
     */
    int powerOnDefaults();
 
    /// Set the framerate.
    /** This uses the acquistion framerate feature.  If m_fpsSet is 0, acuisition framerate is disabled
     * and the resultant framerate is based solely on exposure time and ROI.  If non-zero, then the
     * framerate will be set to m_fpsSet and the camera will maintain this (as long as exposure time
     * and ROI allow).
     *
     * \returns 0 always
     */
    int setFPS();
 
    /// Set the Exposure Time. [stdCamera interface]
    /** Sets the frame rate to m_expTimeSet.
     *
     * \returns 0 on success
     * \returns -1 on error
     */
    int setExpTime();
 
    /// Check the next ROI
    /** Checks if the target values are valid and adjusts them to the closest valid values if needed.
     *
     * \returns 0 always
     */
    int checkNextROI();
 
    /// Set the next ROI
    /**
     * \returns 0 always
     */
    int setNextROI();
 
    std::string stateString();
 
    bool stateStringValid();
 
    ///@}
 
    /** \name Telemeter Interface
     *
     * @{
     */
 
    int checkRecordTimes();
 
    int recordTelem( const telem_stdcam * );
 
    ///@}
};
 
inline baslerCtrl::baslerCtrl() : MagAOXApp( MAGAOX_CURRENT_SHA1, MAGAOX_REPO_MODIFIED )
{
    m_powerMgtEnabled = false;
 
    m_full_x = 335.5;
    m_full_y = 255.5;
    m_full_w = 672;
    m_full_h = 512;
 
    return;
}
 
inline baslerCtrl::~baslerCtrl() noexcept
{
    return;
}
 
void baslerCtrl::setupConfig()
{
 
    config.add( "camera.serialNumber",
                "",
                "camera.serialNumber",
                argType::Required,
                "camera",
                "serialNumber",
                false,
                "int",
                "The identifying serial number of the camera." );
 
    config.add( "camera.bits",
                "",
                "camera.bits",
                argType::Required,
                "camera",
                "bits",
                false,
                "int",
                "The number of bits used by the camera.  Default is 10." );
 
    STDCAMERA_SETUP_CONFIG( config );
 
    FRAMEGRABBER_SETUP_CONFIG( config );
 
    TELEMETER_SETUP_CONFIG( config );
}
 
int baslerCtrl::loadConfigImpl( mx::app::appConfigurator &_config )
{
    config( m_serialNumber, "camera.serialNumber" );
    config( m_bits, "camera.bits" );
 
    STDCAMERA_LOAD_CONFIG( _config );
 
    FRAMEGRABBER_LOAD_CONFIG( _config );
 
    TELEMETER_LOAD_CONFIG( _config );
 
    return 0;
}
 
void baslerCtrl::loadConfig()
{
    if( loadConfigImpl( config ) < 0 )
    {
        log<software_critical>( { __FILE__, __LINE__, "error loading config" } );
        m_shutdown = 1;
    }
}
 
int baslerCtrl::appStartup()
{
    PylonInitialize(); // Initializes pylon runtime before using any pylon methods
 
    STDCAMERA_APP_STARTUP;
 
    FRAMEGRABBER_APP_STARTUP;
 
    TELEMETER_APP_STARTUP;
 
    m_tempHist.maxEntries( 30 );
 
    state( stateCodes::NOTCONNECTED );
 
    return 0;
}
 
int baslerCtrl::appLogic()
{
    STDCAMERA_APP_LOGIC;
 
    FRAMEGRABBER_APP_LOGIC;
 
    if( state() == stateCodes::NOTCONNECTED || state() == stateCodes::NODEVICE || state() == stateCodes::ERROR )
    {
        std::unique_lock<std::mutex> lock( m_indiMutex );
        if( connect() < 0 )
        {
            log<software_error>( { __FILE__, __LINE__ } );
        }
 
        if( state() != stateCodes::CONNECTED )
        {
            return 0;
        }
    }
 
    if( state() == stateCodes::CONNECTED )
    {
        // Get a lock
        std::unique_lock<std::mutex> lock( m_indiMutex );
 
        state( stateCodes::READY );
    }
 
    if( state() == stateCodes::READY || state() == stateCodes::OPERATING )
    {
        // Get a lock if we can
        std::unique_lock<std::mutex> lock( m_indiMutex, std::try_to_lock );
 
        // but don't wait for it, just go back around.
        if( !lock.owns_lock() )
        {
            return 0;
        }
 
        if( getTemp() < 0 )
        {
            if( state() == stateCodes::READY || state() == stateCodes::OPERATING )
            {
                state( stateCodes::ERROR );
            }
 
            return 0;
        }
 
        if( getExpTime() < 0 )
        {
            if( state() == stateCodes::READY || state() == stateCodes::OPERATING )
            {
                state( stateCodes::ERROR );
            }
 
            return 0;
        }
 
        if( getFPS() < 0 )
        {
            if( state() == stateCodes::READY || state() == stateCodes::OPERATING )
            {
                state( stateCodes::ERROR );
            }
 
            return 0;
        }
 
        STDCAMERA_UPDATE_INDI;
 
        FRAMEGRABBER_UPDATE_INDI;
 
        TELEMETER_APP_LOGIC;
    }
 
    ///\todo Fall through check?
 
    return 0;
}
 
int baslerCtrl::appShutdown()
{
    STDCAMERA_APP_SHUTDOWN;
 
    FRAMEGRABBER_APP_SHUTDOWN;
 
    if( m_camera )
    {
        m_camera->Close();
    }
 
    PylonTerminate();
 
    TELEMETER_APP_SHUTDOWN;
 
    return 0;
}
 
int baslerCtrl::connect()
{
    CDeviceInfo info;
    // info.SetDeviceClass(Camera_t::DeviceClass());
    info.SetSerialNumber( m_serialNumber.c_str() );
 
    try
    {
        if( m_camera )
        {
            m_camera->Close();
            delete m_camera;
        }
        m_camera = nullptr;
 
        m_camera = new CBaslerUsbInstantCamera( CTlFactory::GetInstance().CreateFirstDevice( info ) );
    }
    catch( ... )
    {
        if( m_camera )
        {
            m_camera->Close();
            delete m_camera;
        }
        m_camera = nullptr;
 
        state( stateCodes::NODEVICE );
        if( !stateLogged() )
        {
            log<text_log>( "no camera with serial number " + m_serialNumber + " found." );
        }
        return 0;
    }
 
    try
    {
        if( m_shmimName == "" )
        {
            m_shmimName =
                (std::string)m_camera->GetDeviceInfo().GetModelName() + "_" +
                (std::string)m_camera->GetDeviceInfo().GetSerialNumber(); // Gets m_camera model name and serial number
        }
 
        m_camera->RegisterConfiguration(
            new CAcquireContinuousConfiguration, RegistrationMode_ReplaceAll, Cleanup_Delete );
 
        m_camera->Open(); // Opens camera parameters to grab images and set exposure time
    }
    catch( ... )
    {
        if( m_camera )
        {
            m_camera->Close();
            delete m_camera;
        }
        m_camera = nullptr;
 
        state( stateCodes::NODEVICE );
        if( !stateLogged() )
        {
            log<text_log>( "error opening camera " + m_serialNumber + "." );
        }
        return -1;
    }
 
    try
    {
        m_camera->ExposureAuto.SetValue( ExposureAuto_Off );
    }
    catch( ... )
    {
        if( m_camera )
        {
            m_camera->Close();
            delete m_camera;
        }
        m_camera = nullptr;
 
        state( stateCodes::NODEVICE );
        if( !stateLogged() )
        {
            log<text_log>( "failed to set exposure auto off for camera  " + m_serialNumber );
        }
        return -1;
    }
 
    try
    {
        if( m_bits == 8 )
        {
            m_camera->PixelFormat.SetValue( PixelFormat_Mono8 );
        }
        else if( m_bits == 10 )
        {
            m_camera->PixelFormat.SetValue( PixelFormat_Mono10 ); // Set to 10 bits
        }
        else if( m_bits == 12 )
        {
            m_camera->PixelFormat.SetValue( PixelFormat_Mono12 );
        }
        else
        {
            log<text_log>( "unsupported bit depth for camera" + m_serialNumber + "" );
        }
    }
    catch( ... )
    {
        if( m_camera )
        {
            m_camera->Close();
            delete m_camera;
        }
        m_camera = nullptr;
 
        state( stateCodes::NODEVICE );
        if( !stateLogged() )
        {
            log<text_log>( "failed to set bit depth for camera" + m_serialNumber + "" );
        }
        return -1;
    }
 
    state( stateCodes::CONNECTED );
    if( !stateLogged() )
    {
        log<text_log>( "Found camera of type " + (std::string)m_camera->GetDeviceInfo().GetModelName() +
                       " with serial number " + m_serialNumber + "." );
        log<text_log>( "Using shared memory name " + m_shmimName + "." );
    }
 
    m_camera->BinningHorizontalMode.SetValue( BinningHorizontalMode_Sum );
    m_camera->BinningVerticalMode.SetValue( BinningVerticalMode_Sum );
 
    // -- Here we interrogate the camera to find valid ROI settings -- //
 
    // Stop the camera and cycle through settings to get limits for each binning
    m_camera->StopGrabbing();
    m_camera->OffsetX.SetValue( 0 ); // ensure that all values are valid
    m_camera->OffsetY.SetValue( 0 );
 
    int minb = m_camera->BinningHorizontal.GetMin();
    int incb = m_camera->BinningHorizontal.GetInc();
    int maxb = m_camera->BinningHorizontal.GetMax();
 
    m_binXs.clear();
    for( int b = minb; b <= maxb; b += incb )
        m_binXs.push_back( b );
 
    minb = m_camera->BinningVertical.GetMin();
    incb = m_camera->BinningVertical.GetInc();
    maxb = m_camera->BinningVertical.GetMax();
 
    m_binYs.clear();
    for( int b = minb; b <= maxb; b += incb )
        m_binYs.push_back( b );
 
    m_incXs.clear();
    m_minWs.clear();
    m_incWs.clear();
    m_maxWs.clear();
    for( size_t b = 0; b < m_binXs.size(); ++b )
    {
        m_camera->BinningHorizontal.SetValue( m_binXs[b] );
        m_camera->BinningVertical.SetValue( m_binYs[0] );
 
        m_incXs.push_back( m_camera->OffsetX.GetInc() );
        m_minWs.push_back( m_camera->Width.GetMin() );
        m_incWs.push_back( m_camera->Width.GetInc() );
        m_maxWs.push_back( m_camera->Width.GetMax() );
 
        /*//Leave for troubleshooting:
        std::cerr << "--------------------\nH-binning: " << m_binXs[b] << "\n";
        std::cerr << "OffsetX: " << 1 << " " << m_camera->OffsetX.GetInc() << " " << m_camera->Width.GetMax() -
        m_camera->Width.GetMin() << "\n"; std::cerr << "Width: " << m_camera->Width.GetMin() << " " <<
        m_camera->Width.GetInc() << " " << m_camera->Width.GetMax() << "\n"; std::cerr << "OffsetY: " << 1 << " " <<
        m_camera->OffsetY.GetInc() << " " << m_camera->Height.GetMax() - m_camera->Height.GetMin() << "\n"; std::cerr <<
        "Height: " << m_camera->Height.GetMin() << " " << m_camera->Height.GetInc() << " " << m_camera->Height.GetMax()
        << "\n";
        */
    }
 
    m_incYs.clear();
    m_minHs.clear();
    m_incHs.clear();
    m_maxHs.clear();
    for( size_t b = 0; b < m_binYs.size(); ++b )
    {
        m_camera->BinningHorizontal.SetValue( m_binXs[0] );
        m_camera->BinningVertical.SetValue( m_binYs[b] );
 
        m_incYs.push_back( m_camera->OffsetX.GetInc() );
        m_minHs.push_back( m_camera->Height.GetMin() );
        m_incHs.push_back( m_camera->Height.GetInc() );
        m_maxHs.push_back( m_camera->Height.GetMax() );
 
        /*//Leave for troubleshooting:
        std::cerr << "--------------------\nV-binning: " << m_binYs[b] << "\n";
        std::cerr << "OffsetX: " << 1 << " " << m_camera->OffsetX.GetInc() << " " << m_camera->Width.GetMax() -
        m_camera->Width.GetMin() << "\n"; std::cerr << "Width: " << m_camera->Width.GetMin() << " " <<
        m_camera->Width.GetInc() << " " << m_camera->Width.GetMax() << "\n"; std::cerr << "OffsetY: " << 1 << " " <<
        m_camera->OffsetY.GetInc() << " " << m_camera->Height.GetMax() - m_camera->Height.GetMin() << "\n"; std::cerr <<
        "Height: " << m_camera->Height.GetMin() << " " << m_camera->Height.GetInc() << " " << m_camera->Height.GetMax()
        << "\n";
        */
    }
 
    if( m_full_w != m_camera->SensorWidth.GetValue() )
    {
        return log<software_critical, -1>( { __FILE__, __LINE__, "full ROI w (camera.full_w) mismatch with camera" } );
    }
 
    if( m_full_h != m_camera->SensorHeight.GetValue() )
    {
        return log<software_critical, -1>( { __FILE__, __LINE__, "full ROI h (camera.full_h) mismatch with camera" } );
    }
 
    if( m_full_x != 0.5 * ( (float)m_full_w - 1.0 ) )
    {
        return log<software_critical, -1>( { __FILE__, __LINE__, "full ROI x (camera.full_x) mismatch with camera" } );
    }
 
    if( m_full_y != 0.5 * ( (float)m_full_h - 1.0 ) )
    {
        return log<software_critical, -1>( { __FILE__, __LINE__, "full ROI y (camera.full_y) mismatch with camera" } );
    }
 
    return 0;
}
 
int baslerCtrl::configureAcquisition()
{
    if( !m_camera )
    {
        return -1;
    }
 
    try
    {
        recordCamera( true );
        m_camera->StopGrabbing();
        /*
                  The CenterX/Y has to be set to false otherwise the software tries to auto-center the frames.
                  See: https://docs.baslerweb.com/image-roi
             */
        m_camera->CenterX.SetValue( false );
        m_camera->CenterY.SetValue( false );
 
        // set offsets to 0 so any valid w/h will work.
        m_camera->OffsetX.SetValue( 0 );
        m_camera->OffsetY.SetValue( 0 );
 
        if( checkNextROI() < 0 )
        {
            log<software_error>( { __FILE__, __LINE__, "error from checkNextROI()" } );
            return -1;
        }
 
        // Note: assuming checkNextROI has adjusted m_nextROI to valid values, so not doing any checks
        // First find binning indices
        size_t bx = 0;
        for( size_t b = 0; b < m_binXs.size(); ++b )
        {
            if( m_nextROI.bin_x == m_binXs[b] )
            {
                bx = b;
                break;
            }
        }
 
        size_t by = 0;
        for( size_t b = 0; b < m_binYs.size(); ++b )
        {
            if( m_nextROI.bin_y == m_binYs[b] )
            {
                by = b;
                break;
            }
        }
 
        // Set ROI.
        int xoff;
        int yoff;
        if( m_defaultFlip == fgFlipLR || m_defaultFlip == fgFlipUDLR )
        {
            xoff = ( m_maxWs[bx] - 1 - m_nextROI.x ) - 0.5 * ( (float)m_nextROI.w - 1 );
        }
        else
        {
            std::cerr << "m_nextROI.x: " << m_nextROI.x << " m_nextROI.w:" << m_nextROI.w << '\n';
            xoff = m_nextROI.x - 0.5 * ( (float)m_nextROI.w - 1 );
        }
 
        if( m_defaultFlip == fgFlipUD || m_defaultFlip == fgFlipUDLR )
        {
            yoff = ( m_maxHs[by] - 1 - m_nextROI.y ) - 0.5 * ( (float)m_nextROI.h - 1 );
        }
        else
        {
            std::cerr << "m_nextROI.y: " << m_nextROI.y << " m_nextROI.h:" << m_nextROI.h << '\n';
            yoff = m_nextROI.y - 0.5 * ( (float)m_nextROI.h - 1 );
        }
 
        m_camera->BinningHorizontal.SetValue( m_nextROI.bin_x );
        m_camera->BinningVertical.SetValue( m_nextROI.bin_y );
        // Probably not necessary to do it every time, but just in case:
        m_camera->BinningHorizontalMode.SetValue( BinningHorizontalMode_Sum );
        m_camera->BinningVerticalMode.SetValue( BinningVerticalMode_Sum );
 
        m_camera->Width.SetValue( m_nextROI.w );
        m_camera->Height.SetValue( m_nextROI.h );
 
        std::cerr << "xoff: " << xoff << " yoff: " << yoff << '\n';
 
        m_camera->OffsetX.SetValue( xoff );
        m_camera->OffsetY.SetValue( yoff );
 
        // Read the parameter from the camera to check if parameter change is successful
        m_currentROI.bin_x = m_camera->BinningHorizontal.GetValue();
        m_currentROI.bin_y = m_camera->BinningVertical.GetValue();
 
        bx = 0;
        for( size_t b = 0; b < m_binXs.size(); ++b )
        {
            if( m_nextROI.bin_x == m_binXs[b] )
            {
                bx = b;
                break;
            }
        }
 
        by = 0;
        for( size_t b = 0; b < m_binYs.size(); ++b )
        {
            if( m_nextROI.bin_y == m_binYs[b] )
            {
                by = b;
                break;
            }
        }
 
        m_currentROI.w = m_camera->Width.GetValue();
        m_currentROI.h = m_camera->Height.GetValue();
 
        if( m_defaultFlip == fgFlipLR || m_defaultFlip == fgFlipUDLR )
        {
            m_currentROI.x = m_maxWs[bx] - 1 - ( m_camera->OffsetX.GetValue() + 0.5 * ( (float)m_currentROI.w - 1 ) );
        }
        else
        {
            m_currentROI.x = m_camera->OffsetX.GetValue() + 0.5 * ( (float)m_currentROI.w - 1 );
        }
 
        if( m_defaultFlip == fgFlipUD || m_defaultFlip == fgFlipUDLR )
        {
            m_currentROI.y = m_maxHs[by] - 1 - ( m_camera->OffsetY.GetValue() + 0.5 * ( (float)m_currentROI.h - 1 ) );
        }
        else
        {
            m_currentROI.y = m_camera->OffsetY.GetValue() + 0.5 * ( (float)m_currentROI.h - 1 );
        }
 
        // Set the full window for this binning
        m_full_currbin_w = m_maxWs[bx];
        m_full_currbin_x = 0.5 * ( (float)m_full_currbin_w - 1.0 );
        m_full_currbin_h = m_maxHs[by];
        m_full_currbin_y = 0.5 * ( (float)m_full_currbin_h - 1.0 );
 
        // Update binning
        updateIfChanged( m_indiP_roi_x, "current", m_currentROI.x, INDI_OK );
        updateIfChanged( m_indiP_roi_y, "current", m_currentROI.y, INDI_OK );
        updateIfChanged( m_indiP_roi_w, "current", m_currentROI.w, INDI_OK );
        updateIfChanged( m_indiP_roi_h, "current", m_currentROI.h, INDI_OK );
        updateIfChanged( m_indiP_roi_bin_x, "current", m_currentROI.bin_x, INDI_OK );
        updateIfChanged( m_indiP_roi_bin_y, "current", m_currentROI.bin_y, INDI_OK );
 
        // We also update target to the settable values
        m_nextROI.x     = m_currentROI.x;
        m_nextROI.y     = m_currentROI.y;
        m_nextROI.w     = m_currentROI.w;
        m_nextROI.h     = m_currentROI.h;
        m_nextROI.bin_x = m_currentROI.bin_x;
        m_nextROI.bin_y = m_currentROI.bin_y;
 
        updateIfChanged( m_indiP_roi_x, "target", m_nextROI.x, INDI_OK );
        updateIfChanged( m_indiP_roi_y, "target", m_nextROI.y, INDI_OK );
        updateIfChanged( m_indiP_roi_w, "target", m_nextROI.w, INDI_OK );
        updateIfChanged( m_indiP_roi_h, "target", m_nextROI.h, INDI_OK );
        updateIfChanged( m_indiP_roi_bin_x, "target", m_nextROI.bin_x, INDI_OK );
        updateIfChanged( m_indiP_roi_bin_y, "target", m_nextROI.bin_y, INDI_OK );
 
        m_width    = m_currentROI.w;
        m_height   = m_currentROI.h;
        m_dataType = _DATATYPE_INT16;
 
        getFPS();
 
        recordCamera( true );
    }
    catch( ... )
    {
        log<software_error>( { __FILE__, __LINE__, "invalid ROI specifications" } );
        state( stateCodes::NOTCONNECTED );
        return -1;
    }
 
    return 0;
}
 
int baslerCtrl::startAcquisition()
{
    try
    {
        m_camera->StartGrabbing( GrabStrategy_LatestImageOnly ); // Start grabbing, and always grab just the last image.
    }
    catch( ... )
    {
        state( stateCodes::NOTCONNECTED );
        return -1;
    }
 
    state( stateCodes::OPERATING );
 
    return 0;
}
 
int baslerCtrl::acquireAndCheckValid()
{
    try
    {
        m_camera->RetrieveResult( 1000, ptrGrabResult, TimeoutHandling_ThrowException );
    }
    catch( ... )
    {
        state( stateCodes::NOTCONNECTED );
        return -1;
    }
 
    if( ptrGrabResult->GrabSucceeded() ) // If image is grabbed successfully
    {
        clock_gettime( CLOCK_REALTIME, &m_currImageTimestamp );
        return 0;
    }
    else
    {
        state( stateCodes::NOTCONNECTED );
        return -1;
    }
}
 
int baslerCtrl::loadImageIntoStream( void *dest )
{
    pixelT *src = nullptr;
    try
    {
        src = reinterpret_cast<pixelT *>( ptrGrabResult->GetBuffer() );
    }
    catch( ... )
    {
        state( stateCodes::NOTCONNECTED );
        return -1;
    }
 
    if( src == nullptr )
        return -1;
 
    if( frameGrabber<baslerCtrl>::loadImageIntoStreamCopy( dest, src, m_width, m_height, sizeof( pixelT ) ) == nullptr )
        return -1;
 
    return 0;
}
 
int baslerCtrl::reconfig()
{
 
    return 0;
}
 
int baslerCtrl::getTemp()
{
    if( m_camera == nullptr )
        return 0;
 
    try
    {
        float temp = m_camera->DeviceTemperature.GetValue();
        m_tempHist.nextEntry( temp );
 
        temp      = 0;
        int32_t N = m_tempHist.size();
        for( int32_t n = 0; n < N; ++n )
        {
            temp += m_tempHist[n];
        }
        temp /= N;
        m_ccdTemp = temp;
        recordCamera();
    }
    catch( ... )
    {
        m_ccdTemp = -999;
        recordCamera();
        state( stateCodes::NOTCONNECTED );
        return -1;
    }
 
    return 0;
}
 
int baslerCtrl::getExpTime()
{
    if( m_camera == nullptr )
        return 0;
 
    try
    {
        m_expTime = (float)m_camera->ExposureTime.GetValue() / 1e6;
        recordCamera();
    }
    catch( ... )
    {
        m_expTime = -999;
        recordCamera();
        state( stateCodes::NOTCONNECTED );
        return -1;
    }
 
    return 0;
}
 
int baslerCtrl::getFPS()
{
    if( m_camera == nullptr )
        return 0;
 
    try
    {
        m_fps = m_camera->ResultingFrameRate.GetValue();
        recordCamera();
    }
    catch( ... )
    {
        m_fps = -999;
        recordCamera();
        state( stateCodes::NOTCONNECTED );
        return -1;
    }
 
    return 0;
}
 
inline float baslerCtrl::fps()
{
    return m_fps;
}
 
int baslerCtrl::powerOnDefaults()
{
    /*m_nextROI.x     = m_default_x;
    m_nextROI.y     = m_default_y;
    m_nextROI.w     = m_default_w;
    m_nextROI.h     = m_default_h;
    m_nextROI.bin_x = m_default_bin_x;
    m_nextROI.bin_y = m_default_bin_y;*/
 
    return 0;
}
 
int baslerCtrl::setFPS()
{
    if( m_camera == nullptr )
        return 0;
 
    recordCamera( true );
 
    if( m_fpsSet == 0 )
    {
        try
        {
            m_camera->AcquisitionFrameRateEnable.SetValue( false );
        }
        catch( ... )
        {
            return log<software_error, -1>( { __FILE__, __LINE__, "Error disabling frame rate limit." } );
        }
    }
    else
    {
        try
        {
            m_camera->AcquisitionFrameRateEnable.SetValue( true );
            m_camera->AcquisitionFrameRate.SetValue( m_fpsSet );
        }
        catch( ... )
        {
            return log<software_error, -1>( { __FILE__, __LINE__, "Error setting frame rate limit." } );
        }
    }
 
    return 0;
}
 
int baslerCtrl::setExpTime()
{
    if( m_camera == nullptr )
        return 0;
 
    try
    {
        recordCamera( true );
        m_camera->ExposureTime.SetValue( m_expTimeSet * 1e6 );
    }
    catch( ... )
    {
        log<software_error>( { __FILE__, __LINE__, "Error setting exposure time" } );
        return -1;
    }
 
    log<text_log>( "Set exposure time: " + std::to_string( m_expTimeSet ) + " sec" );
 
    return 0;
}
 
int baslerCtrl::checkNextROI()
{
    std::cerr << "checkNextROI!\n";
 
    // First find binning indices
    size_t bx = 0;
    for( size_t b = 0; b < m_binXs.size(); ++b )
    {
        if( m_nextROI.bin_x == m_binXs[b] )
        {
            bx = b;
            break;
        }
    }
    std::cerr << "req bin_x: " << m_nextROI.bin_x << " " << "adj bin_x: " << m_binXs[bx] << "\n";
    m_nextROI.bin_x = m_binXs[bx]; // In case no valid value was found.
 
    size_t by = 0;
    for( size_t b = 0; b < m_binYs.size(); ++b )
    {
        if( m_nextROI.bin_y == m_binYs[b] )
        {
            by = b;
            break;
        }
    }
    std::cerr << "req bin_y: " << m_nextROI.bin_y << " " << "adj bin_y: " << m_binYs[by] << "\n";
    m_nextROI.bin_y = m_binYs[by]; // In case no valid value was found.
 
    // Next check width
    //-- round to nearest increment
    //-- check limits
    int w  = m_nextROI.w;
    int rw = w % m_incWs[bx];
    if( rw < 0.5 * m_incWs[bx] )
        w -= rw;
    else
        w += m_incWs[bx] - rw;
 
    if( w < m_minWs[bx] )
        w = m_minWs[bx];
    else if( w > m_maxWs[bx] )
        w = m_maxWs[bx];
 
    std::cerr << "req w: " << m_nextROI.w << " " << "adj w: " << w << "\n";
    m_nextROI.w = w;
 
    // Now check x
    //-- calculate offset from center
    //-- round to nearest increment
    //-- recalculate center
    int x;
    if( m_defaultFlip == fgFlipLR || m_defaultFlip == fgFlipUDLR )
    {
        x = ( m_maxWs[bx] - 1 - m_nextROI.x ) - 0.5 * ( (float)w - 1 );
    }
    else
    {
        x = m_nextROI.x - 0.5 * ( (float)w - 1 );
    }
 
    int rx = x % m_incXs[bx];
    if( rx < 0.5 * m_incXs[bx] )
        x -= rx;
    else
        x += m_incXs[bx] - rx;
 
    if( x < 0 )
        x = 0;
    else if( x > m_maxWs[bx] - w )
        x = m_maxWs[bx] - w;
 
    std::cerr << "req x: " << m_nextROI.x;
    if( m_defaultFlip == fgFlipLR || m_defaultFlip == fgFlipUDLR )
    {
        m_nextROI.x = m_maxWs[bx] - 1 - ( x + 0.5 * ( (float)w - 1.0 ) );
    }
    else
    {
        m_nextROI.x = x + 0.5 * ( (float)w - 1.0 );
    }
    std::cerr << " adj x: " << m_nextROI.x << "\n";
 
    // Next check height
    //-- round to nearest increment
    //-- check limits
    int h  = m_nextROI.h;
    int rh = h % m_incHs[by];
    if( rh < 0.5 * m_incHs[by] )
        h -= rh;
    else
        h += m_incHs[by] - rh;
 
    if( h < m_minHs[by] )
        h = m_minHs[by];
    else if( h > m_maxHs[by] )
        h = m_maxHs[by];
 
    std::cerr << "req h: " << m_nextROI.h << " " << "adj h: " << h << "\n";
    m_nextROI.h = h;
 
    // Now check y
    //-- calculate offset from center
    //-- round to nearest increment
    //-- recalculate center
    int y;
    if( m_defaultFlip == fgFlipUD || m_defaultFlip == fgFlipUDLR )
    {
        y = ( m_maxHs[by] - 1 - m_nextROI.y ) - 0.5 * ( (float)h - 1 );
    }
    else
    {
        y = m_nextROI.y - 0.5 * ( (float)h - 1 );
    }
 
    int ry = y % m_incYs[by];
    if( ry < 0.5 * m_incYs[by] )
        y -= ry;
    else
        y += m_incYs[by] - ry;
 
    if( y < 0 )
        y = 0;
    else if( y > m_maxHs[by] - h )
        y = m_maxHs[by] - h;
 
    std::cerr << "req y: " << m_nextROI.y;
    if( m_defaultFlip == fgFlipUD || m_defaultFlip == fgFlipUDLR )
    {
        m_nextROI.y = m_maxHs[by] - 1 - ( y + 0.5 * ( (float)h - 1 ) );
    }
    else
    {
        m_nextROI.y = y + 0.5 * ( (float)h - 1 );
    }
    std::cerr << " adj y: " << m_nextROI.y << "\n";
 
    try
    {
        updateIfChanged( m_indiP_roi_x, "target", m_nextROI.x, INDI_OK );
        updateIfChanged( m_indiP_roi_y, "target", m_nextROI.y, INDI_OK );
        updateIfChanged( m_indiP_roi_w, "target", m_nextROI.w, INDI_OK );
        updateIfChanged( m_indiP_roi_h, "target", m_nextROI.h, INDI_OK );
        updateIfChanged( m_indiP_roi_bin_x, "target", m_nextROI.bin_x, INDI_OK );
        updateIfChanged( m_indiP_roi_bin_y, "target", m_nextROI.bin_y, INDI_OK );
 
        return 0;
    }
    catch( const std::exception &e )
    {
        return log<software_error, -1>( { __FILE__, __LINE__, std::string( "Exception caught: " ) + e.what() } );
    }
}
 
int baslerCtrl::setNextROI()
{
    std::cerr << "setNextROI:\n";
    std::cerr << "  m_nextROI.x = " << m_nextROI.x << "\n";
    std::cerr << "  m_nextROI.y = " << m_nextROI.y << "\n";
    std::cerr << "  m_nextROI.w = " << m_nextROI.w << "\n";
    std::cerr << "  m_nextROI.h = " << m_nextROI.h << "\n";
    std::cerr << "  m_nextROI.bin_x = " << m_nextROI.bin_x << "\n";
    std::cerr << "  m_nextROI.bin_y = " << m_nextROI.bin_y << "\n";
 
    m_reconfig = true;
 
    updateSwitchIfChanged( m_indiP_roi_set, "request", pcf::IndiElement::Off, INDI_IDLE );
    updateSwitchIfChanged( m_indiP_roi_full, "request", pcf::IndiElement::Off, INDI_IDLE );
    updateSwitchIfChanged( m_indiP_roi_last, "request", pcf::IndiElement::Off, INDI_IDLE );
    updateSwitchIfChanged( m_indiP_roi_default, "request", pcf::IndiElement::Off, INDI_IDLE );
    return 0;
}
 
std::string baslerCtrl::stateString()
{
    std::string ss;
 
    ss += std::to_string( m_currentROI.x ) + "_" + std::to_string( m_currentROI.y ) + "_";
    ss += std::to_string( m_currentROI.w ) + "x" + std::to_string( m_currentROI.h ) + "_";
    ss += std::to_string( m_currentROI.bin_x ) + "x" + std::to_string( m_currentROI.bin_y ) + "_";
    ss += std::to_string( m_expTime ) + "_";
    ss += std::to_string( floor( m_ccdTemp + 0.5 ) );
 
    return ss;
}
 
bool baslerCtrl::stateStringValid()
{
    return true;
}
 
int baslerCtrl::checkRecordTimes()
{
    return telemeter<baslerCtrl>::checkRecordTimes( telem_stdcam() );
}
 
int baslerCtrl::recordTelem( const telem_stdcam * )
{
    return recordCamera( true );
}
 
} // namespace app
} // namespace MagAOX
#endif