shmimIntegrator.hpp

Go to the documentation of this file.

/** \file shmimIntegrator.hpp
 * \brief The MagAO-X generic ImageStreamIO stream integrator
 *
 * \ingroup app_files
 */
 
#ifndef shmimIntegrator_hpp
#define shmimIntegrator_hpp
 
#include <limits>
 
#include <mx/improc/eigenCube.hpp>
#include <mx/improc/eigenImage.hpp>
 
#include "../../libMagAOX/libMagAOX.hpp" //Note this is included on command line to trigger pch
#include "../../magaox_git_version.h"
 
namespace MagAOX
{
namespace app
{
 
struct darkShmimT
{
    static std::string configSection()
    {
        return "darkShmim";
    };
 
    static std::string indiPrefix()
    {
        return "dark";
    };
};
 
struct dark2ShmimT
{
    static std::string configSection()
    {
        return "dark2Shmim";
    };
 
    static std::string indiPrefix()
    {
        return "dark2";
    };
};
 
/** \defgroup shmimIntegrator ImageStreamIO Stream Integrator
 * \brief Integrates (i.e. averages) an ImageStreamIO image stream.
 *
 * <a href="../handbook/operating/software/apps/shmimIntegrator.html">Application Documentation</a>
 *
 * \ingroup apps
 *
 */
 
/** \defgroup shmimIntegrator_files ImageStreamIO Stream Integrator
 * \ingroup shmimIntegrator
 */
 
/** MagAO-X application to control integrating (averaging) an ImageStreamIO stream
 *
 * \ingroup shmimIntegrator
 *
 */
class shmimIntegrator : public MagAOXApp<true>,
                        public dev::shmimMonitor<shmimIntegrator>,
                        public dev::shmimMonitor<shmimIntegrator, darkShmimT>,
                        public dev::shmimMonitor<shmimIntegrator, dark2ShmimT>,
                        public dev::frameGrabber<shmimIntegrator>,
                        public dev::telemeter<shmimIntegrator>
{
 
    // Give the test harness access.
    friend class shmimIntegrator_test;
 
    friend class dev::shmimMonitor<shmimIntegrator>;
    friend class dev::shmimMonitor<shmimIntegrator, darkShmimT>;
    friend class dev::shmimMonitor<shmimIntegrator, dark2ShmimT>;
    friend class dev::frameGrabber<shmimIntegrator>;
    friend class dev::telemeter<shmimIntegrator>;
 
    // The base shmimMonitor type
    typedef dev::shmimMonitor<shmimIntegrator> shmimMonitorT;
 
    // The dark shmimMonitor type
    typedef dev::shmimMonitor<shmimIntegrator, darkShmimT> darkMonitorT;
 
    // The dark shmimMonitor type for a 2nd dark
    typedef dev::shmimMonitor<shmimIntegrator, dark2ShmimT> dark2MonitorT;
 
    // The base frameGrabber type
    typedef dev::frameGrabber<shmimIntegrator> frameGrabberT;
 
    typedef dev::telemeter<shmimIntegrator> telemeterT;
 
    /// Floating point type in which to do all calculations.
    typedef float realT;
 
  public:
    /** \name app::dev Configurations
     *@{
     */
 
    static constexpr bool c_frameGrabber_flippable =
        false; ///< app:dev config to tell framegrabber these images can not be flipped
 
    ///@}
 
  protected:
    /** \name Configurable Parameters
     *@{
     */
 
    unsigned m_nAverageDefault{ 10 }; ///< The number of frames to average.  Default 10.
 
    std::string m_fpsSource; ///< Device name for getting fps if time-based averaging is used.  This device should have
                             ///< *.fps.current.
 
    float m_avgTime{ 0 }; ///< If non zero, then m_nAverage adjusts automatically to keep a constant averaging time
                          ///< [sec].  Default 0.
 
    unsigned m_nUpdate{ 0 }; ///< The rate at which to update the average.  If 0 < m_nUpdate < m_nAverage then this is a
                             ///< moving averager. Default 0.
 
    bool m_continuous{ true }; ///< Set to false in configuration to have this run once then stop until triggered.
 
    bool m_running{ true }; ///< Set to false in configuration to have it not start averaging until triggered.
 
    std::string m_stateSource; ///< The source of the state string used for file management
 
    bool m_fileSaver{ false }; ///< Set to true in configuration to have this save and reload files automatically.
 
    ///@}
 
    mx::improc::eigenCube<realT> m_accumImages; ///< Cube used to accumulate images
 
    mx::improc::eigenImage<realT> m_avgImage; ///< The average image.
 
    unsigned m_nAverage{ 10 };
 
    float m_fps{ 0 }; ///< Current FPS from the FPS source.
 
    unsigned m_nprocessed{ 0 };
    size_t   m_currImage{ 0 };
    size_t   m_sinceUpdate{ 0 };
    bool     m_updated{ false };
 
    bool        m_imageValid{ false };
    std::string m_stateString;
    bool        m_stateStringValid{ false };
    bool        m_stateStringValidOnStart{ false };
    bool        m_stateStringChanged{ false };
    std::string m_fileSaveDir;
 
    sem_t m_smSemaphore{ 0 }; ///< Semaphore used to synchronize the fg thread and the sm thread.
 
    realT ( *pixget )( void *, size_t ){
        nullptr }; ///< Pointer to a function to extract the image data as our desired type realT.
 
    /// Mutex for locking dark operations.
    std::mutex m_darkMutex;
 
    mx::improc::eigenImage<realT> m_darkImage;
    bool                          m_darkSet{ false };
    bool                          m_darkValid{ false };
    realT ( *dark_pixget )( void *, size_t ){
        nullptr }; ///< Pointer to a function to extract the image data as our desired type realT.
 
    mx::improc::eigenImage<realT> m_dark2Image;
    bool                          m_dark2Set{ false };
    bool                          m_dark2Valid{ false };
    realT ( *dark2_pixget )( void *, size_t ){
        nullptr }; ///< Pointer to a function to extract the image data as our desired type realT.
 
  public:
    /// Default c'tor.
    shmimIntegrator();
 
    /// D'tor, declared and defined for noexcept.
    ~shmimIntegrator() noexcept
    {
    }
 
    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*/ );
 
    virtual void loadConfig();
 
    /// Startup function
    /**
     *
     */
    virtual int appStartup();
 
    /// Implementation of the FSM for shmimIntegrator.
    /**
     * \returns 0 on no critical error
     * \returns -1 on an error requiring shutdown
     */
    virtual int appLogic();
 
    /// Shutdown the app.
    /**
     *
     */
    virtual int appShutdown();
 
  protected:
    int allocate( const dev::shmimT &dummy /**< [in] tag to differentiate shmimMonitor parents.*/ );
 
    int processImage( void              *curr_src, ///< [in] pointer to start of current frame.
                      const dev::shmimT &dummy     ///< [in] tag to differentiate shmimMonitor parents.
    );
 
    int allocate( const darkShmimT &dummy /**< [in] tag to differentiate shmimMonitor parents.*/ );
 
    int processImage( void             *curr_src, ///< [in] pointer to start of current frame.
                      const darkShmimT &dummy     ///< [in] tag to differentiate shmimMonitor parents.
    );
 
    int allocate( const dark2ShmimT &dummy /**< [in] tag to differentiate shmimMonitor parents.*/ );
 
    int processImage( void              *curr_src, ///< [in] pointer to start of current frame.
                      const dark2ShmimT &dummy     ///< [in] tag to differentiate shmimMonitor parents.
    );
 
    int findMatchingDark();
 
    /** \name dev::frameGrabber interface
     *
     * @{
     */
 
    /// Implementation of the framegrabber configureAcquisition interface
    /**
     * \returns 0 on success
     * \returns -1 on error
     */
    int configureAcquisition();
 
    /// Implementation of the framegrabber fps interface
    /**
     * \todo this needs to infer the stream fps and return it
     */
    float fps()
    {
        if( m_fps > 0 && m_nAverage > 0 && ( m_running || m_continuous ) )
        {
            return m_fps / m_nAverage;
        }
        else
        { // this will cause a default averaging
 
            return 1.0;
        }
    }
 
    /// Implementation of the framegrabber startAcquisition interface
    /**
     * \returns 0 on success
     * \returns -1 on error
     */
    int startAcquisition();
 
    /// Implementation of the framegrabber acquireAndCheckValid interface
    /**
     * \returns 0 on success
     * \returns -1 on error
     */
    int acquireAndCheckValid();
 
    /// Implementation of the framegrabber loadImageIntoStream interface
    /**
     * \returns 0 on success
     * \returns -1 on error
     */
    int loadImageIntoStream( void *dest /**< [in] */ );
 
    /// Implementation of the framegrabber reconfig interface
    /**
     * \returns 0 on success
     * \returns -1 on error
     */
    int reconfig();
 
    ///@}
 
    pcf::IndiProperty m_indiP_nAverage;
 
    pcf::IndiProperty m_indiP_avgTime;
 
    pcf::IndiProperty m_indiP_nUpdate;
 
    pcf::IndiProperty m_indiP_startAveraging;
 
    INDI_NEWCALLBACK_DECL( shmimIntegrator, m_indiP_nAverage );
    INDI_NEWCALLBACK_DECL( shmimIntegrator, m_indiP_avgTime );
    INDI_NEWCALLBACK_DECL( shmimIntegrator, m_indiP_nUpdate );
    INDI_NEWCALLBACK_DECL( shmimIntegrator, m_indiP_startAveraging );
 
    pcf::IndiProperty m_indiP_fpsSource;
    INDI_SETCALLBACK_DECL( shmimIntegrator, m_indiP_fpsSource );
 
    pcf::IndiProperty m_indiP_fps; ///< this integrator's FPS
 
    pcf::IndiProperty m_indiP_stateSource;
    INDI_SETCALLBACK_DECL( shmimIntegrator, m_indiP_stateSource );
 
    pcf::IndiProperty m_indiP_imageValid;
 
    /** \name Telemeter Interface
     *
     * @{
     */
    int checkRecordTimes();
 
    int recordTelem( const telem_fgtimings * );
 
    ///@}
};
 
inline shmimIntegrator::shmimIntegrator() : MagAOXApp( MAGAOX_CURRENT_SHA1, MAGAOX_REPO_MODIFIED )
{
    darkMonitorT::m_getExistingFirst = true;
    return;
}
 
inline void shmimIntegrator::setupConfig()
{
    shmimMonitorT::setupConfig( config );
    darkMonitorT::setupConfig( config );
    dark2MonitorT::setupConfig( config );
 
    frameGrabberT::setupConfig( config );
    telemeterT::setupConfig( config );
 
    config.add( "integrator.nAverage",
                "",
                "integrator.nAverage",
                argType::Required,
                "integrator",
                "nAverage",
                false,
                "unsigned",
                "The default number of frames to average.  Default 10. Can be changed via INDI." );
    config.add(
        "integrator.fpsSource",
        "",
        "integrator.fpsSource",
        argType::Required,
        "integrator",
        "fpsSource",
        false,
        "string",
        "Device name for getting fps if time-based averaging is used.  This device should have *.fps.current." );
 
    config.add( "integrator.avgTime",
                "",
                "integrator.avgTime",
                argType::Required,
                "integrator",
                "avgTime",
                false,
                "float",
                "If non zero, then m_nAverage adjusts automatically to keep a constant averaging time [sec].  Default "
                "0. Can be changed via INDI." );
 
    config.add( "integrator.nUpdate",
                "",
                "integrator.nUpdate",
                argType::Required,
                "integrator",
                "nUpdate",
                false,
                "unsigned",
                "The rate at which to update the average.  If 0 < m_nUpdate < m_nAverage then this is a moving "
                "averager. Default 0.  If 0, then it is a simple average." );
 
    config.add( "integrator.continuous",
                "",
                "integrator.continuous",
                argType::Required,
                "integrator",
                "continuous",
                false,
                "bool",
                "Flag controlling whether averaging is continuous or only when triggered.  Default true." );
    config.add( "integrator.running",
                "",
                "integrator.running",
                argType::Required,
                "integrator",
                "running",
                false,
                "bool",
                "Flag controlling whether averaging is running at startup.  Default true." );
 
    config.add( "integrator.stateSource",
                "",
                "integrator.stateSource",
                argType::Required,
                "integrator",
                "stateSource",
                false,
                "string",
                "///< Device name for getting the state string for file management.  This device should have "
                "*.state_string.current." );
    config.add( "integrator.fileSaver",
                "",
                "integrator.fileSaver",
                argType::Required,
                "integrator",
                "fileSaver",
                false,
                "bool",
                "Flag controlling whether this saves and reloads files automatically.  Default false." );
}
 
inline int shmimIntegrator::loadConfigImpl( mx::app::appConfigurator &_config )
{
 
    shmimMonitorT::loadConfig( config );
    darkMonitorT::loadConfig( config );
    dark2MonitorT::loadConfig( config );
 
    frameGrabberT::loadConfig( config );
    telemeterT::loadConfig( config );
 
    _config( m_nAverageDefault, "integrator.nAverage" );
    m_nAverage = m_nAverageDefault;
    _config( m_fpsSource, "integrator.fpsSource" );
    _config( m_avgTime, "integrator.avgTime" );
    _config( m_nUpdate, "integrator.nUpdate" );
 
    _config( m_continuous, "integrator.continuous" );
 
    _config( m_running, "integrator.running" );
 
    _config( m_stateSource, "integrator.stateSource" );
    _config( m_fileSaver, "integrator.fileSaver" );
 
    return 0;
}
 
inline void shmimIntegrator::loadConfig()
{
    loadConfigImpl( config );
}
 
inline int shmimIntegrator::appStartup()
{
 
    createStandardIndiNumber<unsigned>(
        m_indiP_nAverage, "nAverage", 1, std::numeric_limits<unsigned>::max(), 1, "%u" );
    m_indiP_nAverage["current"].set( m_nAverage );
    m_indiP_nAverage["target"].set( m_nAverage );
 
    if( registerIndiPropertyNew( m_indiP_nAverage, INDI_NEWCALLBACK( m_indiP_nAverage ) ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    createStandardIndiNumber<float>( m_indiP_avgTime, "avgTime", 0, std::numeric_limits<float>::max(), 0, "%0.1f" );
    m_indiP_avgTime["current"].set( m_avgTime );
    m_indiP_avgTime["target"].set( m_avgTime );
 
    if( registerIndiPropertyNew( m_indiP_avgTime, INDI_NEWCALLBACK( m_indiP_avgTime ) ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    createStandardIndiNumber<unsigned>( m_indiP_nUpdate, "nUpdate", 1, std::numeric_limits<unsigned>::max(), 1, "%u" );
    m_indiP_nUpdate["current"].set( m_nUpdate );
    m_indiP_nUpdate["target"].set( m_nUpdate );
 
    if( registerIndiPropertyNew( m_indiP_nUpdate, INDI_NEWCALLBACK( m_indiP_nUpdate ) ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    createStandardIndiToggleSw( m_indiP_startAveraging, "start" );
    if( registerIndiPropertyNew( m_indiP_startAveraging, INDI_NEWCALLBACK( m_indiP_startAveraging ) ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    if( m_fpsSource != "" )
    {
        REG_INDI_SETPROP( m_indiP_fpsSource, m_fpsSource, std::string( "fps" ) );
    }
 
    CREATE_REG_INDI_RO_NUMBER( m_indiP_fps, "fps", "", "" );
    m_indiP_fps.add( pcf::IndiElement( "current" ) );
    m_indiP_fps["current"].set( 0 );
 
    if( m_fileSaver == true && m_stateSource != "" )
    {
        REG_INDI_SETPROP( m_indiP_stateSource, m_stateSource, std::string( "state_string" ) );
 
        createROIndiText( m_indiP_imageValid, "image_valid", "flag", "Image Valid", "Image", "Valid" );
        if( !m_imageValid ) // making sure we stay up with default
        {
            m_indiP_imageValid["flag"] = "no";
        }
        else
        {
            m_indiP_imageValid["flag"] = "yes";
        }
 
        if( registerIndiPropertyReadOnly( m_indiP_imageValid ) < 0 )
        {
            log<software_error>( { __FILE__, __LINE__ } );
            return -1;
        }
 
        m_fileSaveDir = m_calibDir + "/" + m_configName;
 
        // Create save directory.
        errno = 0;
        if( mkdir( m_fileSaveDir.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH ) < 0 )
        {
            if( errno != EEXIST )
            {
                std::stringstream logss;
                logss << "Failed to create image directory (" << m_fileSaveDir
                      << ").  Errno says: " << strerror( errno );
                log<software_critical>( { __FILE__, __LINE__, errno, 0, logss.str() } );
 
                return -1;
            }
        }
    }
 
    if( sem_init( &m_smSemaphore, 0, 0 ) < 0 )
    {
        log<software_critical>( { __FILE__, __LINE__, errno, 0, "Initializing S.M. semaphore" } );
        return -1;
    }
 
    if( shmimMonitorT::appStartup() < 0 )
    {
        return log<software_error, -1>( { __FILE__, __LINE__ } );
    }
 
    if( darkMonitorT::appStartup() < 0 )
    {
        return log<software_error, -1>( { __FILE__, __LINE__ } );
    }
 
    if( dark2MonitorT::appStartup() < 0 )
    {
        return log<software_error, -1>( { __FILE__, __LINE__ } );
    }
 
    if( frameGrabberT::appStartup() < 0 )
    {
        return log<software_error, -1>( { __FILE__, __LINE__ } );
    }
 
    if( telemeterT::appStartup() < 0 )
    {
        return log<software_error, -1>( { __FILE__, __LINE__ } );
    }
 
    state( stateCodes::READY );
 
    return 0;
}
 
inline int shmimIntegrator::appLogic()
{
    if( shmimMonitorT::appLogic() < 0 )
    {
        return log<software_error, -1>( { __FILE__, __LINE__ } );
    }
 
    if( darkMonitorT::appLogic() < 0 )
    {
        return log<software_error, -1>( { __FILE__, __LINE__ } );
    }
 
    if( dark2MonitorT::appLogic() < 0 )
    {
        return log<software_error, -1>( { __FILE__, __LINE__ } );
    }
 
    if( frameGrabberT::appLogic() < 0 )
    {
        return log<software_error, -1>( { __FILE__, __LINE__ } );
    }
 
    if( telemeterT::appLogic() < 0 )
    {
        return log<software_error, -1>( { __FILE__, __LINE__ } );
    }
 
    std::unique_lock<std::mutex> lock( m_indiMutex );
 
    if( shmimMonitorT::updateINDI() < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
    }
 
    if( darkMonitorT::updateINDI() < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
    }
 
    if( dark2MonitorT::updateINDI() < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
    }
 
    if( frameGrabberT::updateINDI() < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
    }
 
    if( m_running == false )
    {
        state( stateCodes::READY );
        updateSwitchIfChanged( m_indiP_startAveraging, "toggle", pcf::IndiElement::Off, INDI_IDLE );
 
        if( m_fileSaver )
        {
            if( m_stateStringChanged ) // So if not running and the state has changed, we check
            {
                if( findMatchingDark() < 0 )
                {
                    log<software_error>( { __FILE__, __LINE__ } );
                }
            }
 
            if( !m_imageValid )
            {
                updateIfChanged( m_indiP_imageValid, "flag", "no" );
            }
            else
            {
                updateIfChanged( m_indiP_imageValid, "flag", "yes" );
            }
        }
    }
    else
    {
        state( stateCodes::OPERATING );
        updateSwitchIfChanged( m_indiP_startAveraging, "toggle", pcf::IndiElement::On, INDI_BUSY );
    }
 
    updateIfChanged( m_indiP_nAverage, "current", m_nAverage, INDI_IDLE );
    updateIfChanged( m_indiP_nAverage, "target", m_nAverage, INDI_IDLE );
 
    updateIfChanged( m_indiP_avgTime, "current", m_avgTime, INDI_IDLE );
    updateIfChanged( m_indiP_avgTime, "target", m_avgTime, INDI_IDLE );
 
    updateIfChanged( m_indiP_nUpdate, "current", m_nUpdate, INDI_IDLE );
    updateIfChanged( m_indiP_nUpdate, "target", m_nUpdate, INDI_IDLE );
 
    updateIfChanged( m_indiP_fps, "current", fps(), INDI_OK );
 
    return 0;
}
 
inline int shmimIntegrator::appShutdown()
{
    shmimMonitorT::appShutdown();
 
    darkMonitorT::appShutdown();
 
    dark2MonitorT::appShutdown();
 
    frameGrabberT::appShutdown();
 
    telemeterT::appShutdown();
 
    return 0;
}
 
inline int shmimIntegrator::allocate( const dev::shmimT &dummy )
{
    static_cast<void>( dummy ); // be unused
 
    // This whole thing could invalidate the dark.
    std::unique_lock<std::mutex> lock( m_darkMutex ); // Lock the mutex before messing with the dark.
 
    if( m_avgTime > 0 && m_fps > 0 )
    {
        m_nAverage = m_avgTime * m_fps;
        if( m_nAverage <= 0 )
        {
            m_nAverage = 1;
        }
        log<text_log>( "set nAverage to " + std::to_string( m_nAverage ) + " based on FPS", logPrio::LOG_NOTICE );
    }
    else if( m_avgTime > 0 && m_fps == 0 ) // Haven't gotten the update yet so we keep going for now
    {
        if( m_nAverage != m_nAverageDefault )
        {
            m_nAverage = m_nAverageDefault;
            log<text_log>( "set nAverage to default " + std::to_string( m_nAverage ), logPrio::LOG_NOTICE );
        }
    }
 
    if( m_nUpdate > 0 )
    {
        m_accumImages.resize( shmimMonitorT::m_width, shmimMonitorT::m_height, m_nAverage );
        m_accumImages.setZero();
    }
    else
    {
        m_accumImages.resize( 1, 1, 1 );
    }
 
    m_nprocessed  = 0;
    m_currImage   = 0;
    m_sinceUpdate = 0;
 
    m_avgImage.resize( shmimMonitorT::m_width, shmimMonitorT::m_height );
    // m_avgImage.setZero();
 
    pixget = getPixPointer<realT>( shmimMonitorT::m_dataType );
 
    if( pixget == nullptr )
    {
        log<software_error>( { __FILE__, __LINE__, "bad data type" } );
        return -1;
    }
 
    updateIfChanged( m_indiP_nAverage, "current", m_nAverage, INDI_IDLE );
    updateIfChanged( m_indiP_nAverage, "target", m_nAverage, INDI_IDLE );
 
    updateIfChanged( m_indiP_avgTime, "current", m_avgTime, INDI_IDLE );
    updateIfChanged( m_indiP_avgTime, "target", m_avgTime, INDI_IDLE );
 
    updateIfChanged( m_indiP_nUpdate, "current", m_nUpdate, INDI_IDLE );
    updateIfChanged( m_indiP_nUpdate, "target", m_nUpdate, INDI_IDLE );
 
    if( darkMonitorT::m_width == shmimMonitorT::m_width || darkMonitorT::m_height == shmimMonitorT::m_height )
    {
        m_darkValid = true;
    }
    else
    {
        m_darkValid = false;
    }
 
    if( dark2MonitorT::m_width == shmimMonitorT::m_width || dark2MonitorT::m_height == shmimMonitorT::m_height )
    {
        m_dark2Valid = true;
    }
    else
    {
        m_dark2Valid = false;
    }
 
    m_reconfig = true;
 
    return 0;
}
 
inline int shmimIntegrator::processImage( void *curr_src, const dev::shmimT &dummy )
{
    static_cast<void>( dummy ); // be unused
 
    if( !m_running )
        return 0;
 
    if( m_nUpdate == 0 )
    {
        if( m_updated )
            return 0;
        if( m_sinceUpdate == 0 )
            m_avgImage.setZero();
 
        realT *data = m_avgImage.data();
 
        for( unsigned nn = 0; nn < shmimMonitorT::m_width * shmimMonitorT::m_height; ++nn )
        {
            data[nn] += pixget( curr_src, nn );
        }
        ++m_sinceUpdate;
        if( m_sinceUpdate >= m_nAverage )
        {
            m_avgImage /= m_nAverage; ///\todo should this be /= m_sinceUpdate?
 
            if( ( m_darkSet && m_darkValid ) && !( m_dark2Set && m_dark2Valid ) )
            {
                std::unique_lock<std::mutex> lock( m_darkMutex ); // Lock the mutex before messing with the dark.
                m_avgImage -= m_darkImage;
            }
            else if( !( m_darkSet && m_darkValid ) && ( m_dark2Set && m_dark2Valid ) )
            {
                std::unique_lock<std::mutex> lock( m_darkMutex ); // Lock the mutex before messing with the dark.
                m_avgImage -= m_dark2Image;
            }
            else if( ( m_darkSet && m_darkValid ) && ( m_dark2Set && m_dark2Valid ) )
            {
                std::unique_lock<std::mutex> lock( m_darkMutex ); // Lock the mutex before messing with the dark.
                m_avgImage -= m_darkImage + m_dark2Image;
            }
 
            m_updated = true;
 
            // Now tell the f.g. to get going
            if( sem_post( &m_smSemaphore ) < 0 )
            {
                log<software_critical>( { __FILE__, __LINE__, errno, 0, "Error posting to semaphore" } );
                return -1;
            }
 
            m_sinceUpdate = 0;
            if( !m_continuous )
            {
                m_running = false;
                if( m_fileSaver )
                {
                    if( m_stateStringChanged || !m_stateStringValid || !m_stateStringValidOnStart )
                    {
                        m_imageValid = false;
                        log<text_log>( "state changed during acquisition, not saving", logPrio::LOG_NOTICE );
                    }
                    else
                    {
                        m_imageValid         = true;
                        m_stateStringChanged = false;
 
                        ///\todo this should happen in a different less-real-time thread.
                        // Otherwise we save:
                        timespec fts;
                        clock_gettime( CLOCK_REALTIME, &fts );
 
                        tm uttime; // The broken down time.
 
                        if( gmtime_r( &fts.tv_sec, &uttime ) == 0 )
                        {
                            // Yell at operator but keep going
                            log<software_alert>( { __FILE__,
                                                   __LINE__,
                                                   errno,
                                                   0,
                                                   "gmtime_r error.  possible loss of timing information." } );
                        }
 
                        char cts[] = "YYYYMMDDHHMMSSNNNNNNNNN";
                        int  rv    = snprintf( cts,
                                           sizeof( cts ),
                                           "%04i%02i%02i%02i%02i%02i%09i",
                                           uttime.tm_year + 1900,
                                           uttime.tm_mon + 1,
                                           uttime.tm_mday,
                                           uttime.tm_hour,
                                           uttime.tm_min,
                                           uttime.tm_sec,
                                           static_cast<int>( fts.tv_nsec ) );
 
                        if( rv != sizeof( cts ) - 1 )
                        {
                            // Something is very wrong.  Keep going to try to get it on disk.
                            log<software_alert>(
                                { __FILE__, __LINE__, errno, rv, "did not write enough chars to timestamp" } );
                        }
 
                        std::string fname =
                            m_fileSaveDir + "/" + m_configName + "_" + m_stateString + "__T" + cts + ".fits";
 
                        mx::fits::fitsFile<float> ff;
                        ff.write( fname, m_avgImage );
                        log<text_log>( "Wrote " + fname );
                    }
                }
            }
        }
    }
    else
    {
        realT *data = m_accumImages.image( m_currImage ).data();
 
        for( unsigned nn = 0; nn < shmimMonitorT::m_width * shmimMonitorT::m_height; ++nn )
        {
            data[nn] = pixget( curr_src, nn );
        }
        ++m_nprocessed;
        ++m_currImage;
        if( m_currImage >= m_nAverage )
            m_currImage = 0;
 
        if( m_nprocessed < m_nAverage ) // Check that we are burned in on first pass through cube
        {
            return 0;
        }
 
        ++m_sinceUpdate;
 
        if( m_sinceUpdate >= m_nUpdate )
        {
            if( m_updated )
            {
                return 0; // In case f.g. thread is behind, we skip and come back.
            }
            // Don't use eigenCube functions to avoid any omp
            m_avgImage.setZero();
            for( size_t n = 0; n < m_nAverage; ++n )
            {
                for( size_t ii = 0; ii < shmimMonitorT::m_width; ++ii )
                {
                    for( size_t jj = 0; jj < shmimMonitorT::m_height; ++jj )
                    {
                        m_avgImage( ii, jj ) += m_accumImages.image( n )( ii, jj );
                    }
                }
            }
            m_avgImage /= m_nAverage;
 
            if( m_darkValid && m_darkSet )
            {
                std::unique_lock<std::mutex> lock( m_darkMutex ); // Lock the mutex before messing with the dark.
                m_avgImage -= m_darkImage;
            }
 
            m_updated = true;
 
            // Now tell the f.g. to get going
            if( sem_post( &m_smSemaphore ) < 0 )
            {
                log<software_critical>( { __FILE__, __LINE__, errno, 0, "Error posting to semaphore" } );
                return -1;
            }
 
            m_sinceUpdate = 0;
        }
    }
    return 0;
}
 
inline int shmimIntegrator::allocate( const darkShmimT &dummy )
{
    static_cast<void>( dummy ); // be unused
 
    std::unique_lock<std::mutex> lock( m_darkMutex ); // Lock the mutex before messing with the dark.
 
    m_darkImage.resize( darkMonitorT::m_width, darkMonitorT::m_height );
    m_darkImage.setZero();
 
    dark_pixget = getPixPointer<realT>( darkMonitorT::m_dataType );
 
    if( dark_pixget == nullptr )
    {
        log<software_error>( { __FILE__, __LINE__, "bad data type" } );
        m_darkSet   = false;
        m_darkValid = false;
        return -1;
    }
 
    if( darkMonitorT::m_width == shmimMonitorT::m_width || darkMonitorT::m_height == shmimMonitorT::m_height )
    {
        m_darkValid = true;
    }
    else
    {
        m_darkValid = false;
    }
 
    return 0;
}
 
inline int shmimIntegrator::processImage( void *curr_src, const darkShmimT &dummy )
{
    static_cast<void>( dummy ); // be unused
 
    realT *data = m_darkImage.data();
 
    for( unsigned nn = 0; nn < darkMonitorT::m_width * darkMonitorT::m_height; ++nn )
    {
        // data[nn] = *( (int16_t * ) (curr_src + nn*shmimMonitorT::m_typeSize));
        data[nn] = dark_pixget( curr_src, nn );
    }
 
    m_darkSet = true; // There is a dark set and ready to use, but it may or may not be valid.
 
    return 0;
}
 
inline int shmimIntegrator::allocate( const dark2ShmimT &dummy )
{
    static_cast<void>( dummy ); // be unused
 
    std::unique_lock<std::mutex> lock( m_darkMutex ); // Lock the mutex before messing with the dark.
 
    m_dark2Image.resize( dark2MonitorT::m_width, dark2MonitorT::m_height );
    m_dark2Image.setZero();
 
    dark2_pixget = getPixPointer<realT>( dark2MonitorT::m_dataType );
 
    if( dark2_pixget == nullptr )
    {
        log<software_error>( { __FILE__, __LINE__, "bad data type" } );
        m_dark2Set   = false;
        m_dark2Valid = false;
        return -1;
    }
 
    if( dark2MonitorT::m_width == shmimMonitorT::m_width || dark2MonitorT::m_height == shmimMonitorT::m_height )
    {
        m_dark2Valid = true;
    }
    else
    {
        m_dark2Valid = false;
    }
 
    return 0;
}
 
inline int shmimIntegrator::processImage( void *curr_src, const dark2ShmimT &dummy )
{
    static_cast<void>( dummy ); // be unused
 
    realT *data = m_dark2Image.data();
 
    for( unsigned nn = 0; nn < dark2MonitorT::m_width * dark2MonitorT::m_height; ++nn )
    {
        // data[nn] = *( (int16_t * ) (curr_src + nn*shmimMonitorT::m_typeSize));
        data[nn] = dark2_pixget( curr_src, nn );
    }
 
    m_dark2Set = true; // There is a dark set and ready to use, but it may or may not be valid.
 
    return 0;
}
 
inline int shmimIntegrator::findMatchingDark()
{
    std::vector<std::string> fnames = mx::ioutils::getFileNames( m_fileSaveDir, m_configName, "", ".fits" );
 
    // getFileNames sorts, so these will be in oldest to newest order by lexical timestamp sort
    // So we search in reverse to always pick newest
    long N = fnames.size();
    for( long n = N - 1; n >= 0; --n )
    {
        std::string fn = mx::ioutils::pathStem( fnames[n] );
 
        if( fn.size() < m_configName.size() + 1 )
            continue;
 
        size_t st = m_configName.size() + 1;
        size_t ed = fn.find( "__T" );
        if( ed == std::string::npos || ed - st < 2 )
            continue;
        std::string stateStr = fn.substr( st, ed - st );
 
        if( stateStr == m_stateString )
        {
            mx::fits::fitsFile<float> ff;
            ff.read( m_avgImage, fnames[n] );
 
            if( m_avgImage.rows() != shmimMonitorT::m_width || m_avgImage.cols() != shmimMonitorT::m_height )
            {
                // Means the camera has changed but stream hasn't caught up
                //(This happens on startup before stream connection completes.)
 
                // And possibly that we haven't turned the shmimMonitor on yet by switching to OPERATING
                if( shmimMonitorT::m_width == 0 && shmimMonitorT::m_height == 0 )
                {
                    sleep( 1 ); // wait for everything else to get initialized
                    shmimMonitorT::m_width  = m_avgImage.rows();
                    shmimMonitorT::m_height = m_avgImage.cols();
                    m_reconfig              = true;
                }
                else
                {
                    if( m_running )
                        return 0;
                    m_imageValid         = false;
                    m_stateStringChanged = true; // So we let appLogic try again next time around.
                    return 0;
                }
            }
 
            if( m_running )
                return 0;
 
            m_updated = true;
            // Now tell the f.g. to get going
            if( sem_post( &m_smSemaphore ) < 0 )
            {
                log<software_critical>( { __FILE__, __LINE__, errno, 0, "Error posting to semaphore" } );
                return -1;
            }
            m_imageValid         = true;
            m_stateStringChanged = false;
 
            log<text_log>( "loaded last matching dark from disk", logPrio::LOG_NOTICE );
 
            return 0;
        }
    }
 
    if( m_running )
        return 0;
 
    m_imageValid         = false;
    m_stateStringChanged = false; // stop trying b/c who else is going to add a dark?
 
    log<text_log>( "dark is not valid", logPrio::LOG_WARNING );
 
    return 0;
}
 
inline int shmimIntegrator::configureAcquisition()
{
    std::unique_lock<std::mutex> lock( m_indiMutex );
 
    ///\todo potential but verrrrry unlikely bug: shmimMonitorT could change these before allocate sets the lock above.
    ///Should use a local set of w/h instead.
    if( shmimMonitorT::m_width == 0 || shmimMonitorT::m_height == 0 )
    {
        // This means we haven't connected to the stream to average. so wait.
        lock.unlock(); // don't hold the lock for a whole second.
        sleep( 1 );
        return -1;
    }
 
    frameGrabberT::m_width    = shmimMonitorT::m_width;
    frameGrabberT::m_height   = shmimMonitorT::m_height;
    frameGrabberT::m_dataType = _DATATYPE_FLOAT;
 
    return 0;
}
 
inline int shmimIntegrator::startAcquisition()
{
    return 0;
}
 
inline int shmimIntegrator::acquireAndCheckValid()
{
    timespec ts;
 
    if( clock_gettime( CLOCK_REALTIME, &ts ) < 0 )
    {
        log<software_critical>( { __FILE__, __LINE__, errno, 0, "clock_gettime" } );
        return -1;
    }
 
    ts.tv_sec += 1;
 
    if( sem_timedwait( &m_smSemaphore, &ts ) == 0 )
    {
        if( m_updated )
        {
            clock_gettime( CLOCK_REALTIME, &m_currImageTimestamp );
            return 0;
        }
        else
        {
            return 1;
        }
    }
    else
    {
        return 1;
    }
}
 
inline int shmimIntegrator::loadImageIntoStream( void *dest )
{
    memcpy( dest, m_avgImage.data(), shmimMonitorT::m_width * shmimMonitorT::m_height * frameGrabberT::m_typeSize );
    m_updated = false;
    return 0;
}
 
inline int shmimIntegrator::reconfig()
{
    return 0;
}
 
INDI_NEWCALLBACK_DEFN( shmimIntegrator, m_indiP_nAverage )( const pcf::IndiProperty &ipRecv )
{
    if( ipRecv.getName() != m_indiP_nAverage.getName() )
    {
        log<software_error>( { __FILE__, __LINE__, "invalid indi property received" } );
        return -1;
    }
 
    unsigned target;
 
    if( indiTargetUpdate( m_indiP_nAverage, target, ipRecv, true ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    m_nAverage = target;
 
    if( m_avgTime > 0 && m_fps > 0 )
    {
        m_avgTime = m_nAverage / m_fps;
    }
 
    updateIfChanged( m_indiP_nAverage, "current", m_nAverage, INDI_IDLE );
    updateIfChanged( m_indiP_nAverage, "target", m_nAverage, INDI_IDLE );
 
    updateIfChanged( m_indiP_avgTime, "current", m_avgTime, INDI_IDLE );
    updateIfChanged( m_indiP_avgTime, "target", m_avgTime, INDI_IDLE );
 
    shmimMonitorT::m_restart = true;
 
    log<text_log>( "set nAverage to " + std::to_string( m_nAverage ), logPrio::LOG_NOTICE );
 
    return 0;
}
 
INDI_NEWCALLBACK_DEFN( shmimIntegrator, m_indiP_avgTime )( const pcf::IndiProperty &ipRecv )
{
    if( ipRecv.getName() != m_indiP_avgTime.getName() )
    {
        log<software_error>( { __FILE__, __LINE__, "invalid indi property received" } );
        return -1;
    }
 
    float target;
 
    if( indiTargetUpdate( m_indiP_avgTime, target, ipRecv, true ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    m_avgTime = target;
 
    updateIfChanged( m_indiP_avgTime, "current", m_avgTime, INDI_IDLE );
    updateIfChanged( m_indiP_avgTime, "target", m_avgTime, INDI_IDLE );
 
    shmimMonitorT::m_restart = true;
 
    log<text_log>( "set avgTime to " + std::to_string( m_avgTime ), logPrio::LOG_NOTICE );
 
    return 0;
}
 
INDI_NEWCALLBACK_DEFN( shmimIntegrator, m_indiP_nUpdate )( const pcf::IndiProperty &ipRecv )
{
    if( ipRecv.getName() != m_indiP_nUpdate.getName() )
    {
        log<software_error>( { __FILE__, __LINE__, "invalid indi property received" } );
        return -1;
    }
 
    unsigned target;
 
    if( indiTargetUpdate( m_indiP_nUpdate, target, ipRecv, true ) < 0 )
    {
        log<software_error>( { __FILE__, __LINE__ } );
        return -1;
    }
 
    m_nUpdate = target;
 
    updateIfChanged( m_indiP_nUpdate, "current", m_nUpdate, INDI_IDLE );
    updateIfChanged( m_indiP_nUpdate, "target", m_nUpdate, INDI_IDLE );
 
    shmimMonitorT::m_restart = true;
 
    log<text_log>( "set nUpdate to " + std::to_string( m_nUpdate ), logPrio::LOG_NOTICE );
 
    return 0;
}
 
INDI_NEWCALLBACK_DEFN( shmimIntegrator, m_indiP_startAveraging )( const pcf::IndiProperty &ipRecv )
{
    if( ipRecv.getName() != m_indiP_startAveraging.getName() )
    {
        log<software_error>( { __FILE__, __LINE__, "invalid indi property received" } );
        return -1;
    }
 
    if( !ipRecv.find( "toggle" ) )
        return 0;
 
    if( ipRecv["toggle"].getSwitchState() == pcf::IndiElement::Off )
    {
        std::unique_lock<std::mutex> lock( m_indiMutex );
 
        m_running = false;
 
        state( stateCodes::READY );
 
        updateSwitchIfChanged( m_indiP_startAveraging, "toggle", pcf::IndiElement::Off, INDI_IDLE );
    }
 
    if( ipRecv["toggle"].getSwitchState() == pcf::IndiElement::On )
    {
        std::unique_lock<std::mutex> lock( m_indiMutex );
 
        if( m_fileSaver && !m_continuous )
            m_stateStringChanged = false; // We reset this here so we can detect a change at the end of the integration
 
        m_stateStringValidOnStart = m_stateStringValid;
        m_running                 = true;
 
        state( stateCodes::OPERATING );
 
        updateSwitchIfChanged( m_indiP_startAveraging, "toggle", pcf::IndiElement::On, INDI_BUSY );
    }
    return 0;
}
 
INDI_SETCALLBACK_DEFN( shmimIntegrator, m_indiP_fpsSource )( const pcf::IndiProperty &ipRecv )
{
    if( ipRecv.getName() != m_indiP_fpsSource.getName() )
    {
        log<software_error>( { __FILE__, __LINE__, "Invalid INDI property." } );
        return -1;
    }
 
    if( ipRecv.find( "current" ) != true ) // this isn't valie
    {
        return 0;
    }
 
    std::lock_guard<std::mutex> guard( m_indiMutex );
 
    realT fps = ipRecv["current"].get<float>();
 
    if( fps != m_fps )
    {
        m_fps = fps;
        std::cout << "Got fps: " << m_fps << "\n";
        shmimMonitorT::m_restart  = true;
        frameGrabberT::m_reconfig = true;
    }
 
    return 0;
}
 
INDI_SETCALLBACK_DEFN( shmimIntegrator, m_indiP_stateSource )( const pcf::IndiProperty &ipRecv )
{
    if( ipRecv.getName() != m_indiP_stateSource.getName() )
    {
        log<software_error>( { __FILE__, __LINE__, "Invalid INDI property." } );
        return -1;
    }
 
    if( ipRecv.find( "valid" ) == true )
    {
        bool stateStringValid;
        if( ipRecv["valid"].get<std::string>() == "yes" )
            stateStringValid = true;
        else
            stateStringValid = false;
 
        if( stateStringValid != m_stateStringValid )
            m_stateStringChanged = true;
 
        m_stateStringValid = stateStringValid;
    }
 
    if( ipRecv.find( "current" ) != true )
    {
        return 0;
    }
 
    std::lock_guard<std::mutex> guard( m_indiMutex );
 
    std::string ss = ipRecv["current"].get<std::string>();
 
    if( ss != m_stateString )
    {
        m_stateString = ss;
        m_imageValid  = false; // This will mark the current dark invalid
        updateIfChanged( m_indiP_imageValid, "flag", "no" );
        m_stateStringChanged = true; // We declare it changed.  This can have two effects:
                                     //  1) if we are not currently integrating, it will start a lookup in appLogic
                                     //  2) if we are integrating, after it finishes it will not be declared valid and
                                     //  then we'll lookup in appLogic
    }
 
    return 0;
}
 
inline int shmimIntegrator::checkRecordTimes()
{
    return telemeterT::checkRecordTimes( telem_fgtimings() );
}
 
inline int shmimIntegrator::recordTelem( const telem_fgtimings * )
{
    return recordFGTimings( true );
}
 
} // namespace app
} // namespace MagAOX
 
#endif // shmimIntegrator_hpp