TAPsSensAble_hduRecord.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsSensAble_hduRecord.cpp

Modified from SensAble hduRecord.cpp

SUKITTI PUNAK   (11/27/2006)
UPDATE          (11/27/2006)
******************************************************************************/
#include "TAPsSensAble_hduRecord.hpp"
// Using Inclusion Model (i.e. definitions are included in declarations)
//                       (this name.cpp is included in name.hpp)
// Each friend is defined directly inside its declaration.


// Original comment from hduRecord.cpp
/*****************************************************************************

Copyright (c) 2004 SensAble Technologies, Inc. All rights reserved.

OpenHaptics(TM) toolkit. The material embodied in this software and use of
this software is subject to the terms and conditions of the clickthrough
Development License Agreement.

For questions, comments or bug reports, go to forums at: 
    http://dsc.sensable.com

Module Name:

  hduRecord.cpp

Description: 

  Records device data from the scheduler for a specified number of ticks, and 
  with option to add additional user data.

******************************************************************************/

//#include "hduAfx.h"

#include <iostream>

#include <HDU/hduRecord.h>
#include <HDU/hduVector.h>

#include <HD/hdCompilerConfig.h>
#include <HD/hdScheduler.h>
#include <HD/hdDevice.h>

BEGIN_NAMESPACE_TAPs__Haptic
//=============================================================================

#if defined WIN32
# include <process.h>
  typedef void thread_rv;
#elif defined(linux) || defined(__APPLE__)
# include <pthread.h>
  typedef void* thread_rv;
#endif

/* Scheduler callback for getting data for each iteration. */
HDCallbackCode HDCALLBACK SensAble_RecordLoopCallback ( 
    void * SensAble_hduRecorder );

/* Thread callback for writing out data to file. */
thread_rv SensAble_RecordWriteCallback( void * data );

/******************************************************************************
 Data packet for each iteration. 
******************************************************************************/
struct SensAble_hduRecorderPacket
{
    hduVector3Dd    m_force;
    hduVector3Dd    m_position;
    hduVector3Dd    m_velocity;
    char *          m_userData;
};

/******************************************************************************
 Main class that handles recording. 
******************************************************************************/
class SensAble_hduRecorder
{
    //---------------------------------------------------------------
public:
    SensAble_hduRecorder (
        FILE *              file,
        HDURecordCallback & pUserCallback,
        void *              pUserCallbackData,
        int                 numData
    );
    virtual ~SensAble_hduRecorder ();
    HDboolean Start ();
    HDboolean AddData ();
    void WriteDataToFile ();
    //---------------------------------
    // HDSchedulerHandle is unsigned long.
    HDSchedulerHandle GetShedulerHandle () { return m_hdSchedulerHandle; }
    //-----------------------
//  HDboolean GetStatusCompletion () {
//      if ( m_hdSchedulerHandle == 0 ) return true;
//      return !hdWaitForCompletion( m_hdSchedulerHandle, HD_WAIT_CHECK_STATUS );
//  }
    //---------------------------------------------------------------
private:
    SensAble_HDURecordCallback *    m_pUserCallback;
    void *                          m_pUserCallbackData;
    FILE *                          m_file;
    int                             m_numData;
    int                             m_index;
    SensAble_hduRecorderPacket *    m_data;
    //---------------------------------
    // For checking completion status
    HDSchedulerHandle               m_hdSchedulerHandle;
};

/******************************************************************************
 Constructor
******************************************************************************/
SensAble_hduRecorder::SensAble_hduRecorder (
    FILE *                          file,
    SensAble_HDURecordCallback &    pUserCallback,
    void *                          pUserCallbackData,
    int                             numData
) :
    m_file( file ),
    m_pUserCallback( pUserCallback ),
    m_pUserCallbackData( pUserCallbackData ),
    m_numData( numData ),
    m_index( 0 ),
    m_data( 0 ), 
    m_hdSchedulerHandle( 0 )
{
    m_data = new SensAble_hduRecorderPacket[ numData ];
}

/******************************************************************************
 Destructor
******************************************************************************/
SensAble_hduRecorder::~SensAble_hduRecorder ()
{
    for ( int i = 0; i < m_numData; ++i ) {
        delete m_data[i].m_userData;
    }
    delete[] m_data;
}

/******************************************************************************
 Start the recording.  Schedule a callback that records device data for 
 every scheduler tick. 
******************************************************************************/
HDboolean SensAble_hduRecorder::Start ()
{
    m_hdSchedulerHandle = hdScheduleAsynchronous(
        SensAble_RecordLoopCallback,
        this,
        HD_MIN_SCHEDULER_PRIORITY
    );
    return ( m_hdSchedulerHandle == HD_INVALID_HANDLE ? false : true );
}

/******************************************************************************
 Worker thread callback to write the data to file.
******************************************************************************/
thread_rv SensAble_RecordWriteCallback ( void * data )
{
    SensAble_hduRecorder * pRecord = ( SensAble_hduRecorder * ) data;
    pRecord->WriteDataToFile();
    delete pRecord;
}

/******************************************************************************
 Write all the data out at once when the recording is done.
******************************************************************************/
void SensAble_hduRecorder::WriteDataToFile ()
{
    //*
    //---------------------------------------------------------------
    // Without data names
    for ( int i = 0; i < m_numData; ++i ) {
        SensAble_hduRecorderPacket & data = m_data[i];
        fprintf( m_file, "%d\t", i );
        fprintf( m_file, "%f %f %f\t", 
                data.m_force[0],
                data.m_force[1],
                data.m_force[2] );
        fprintf( m_file,"%f %f %f\t", 
                data.m_position[0],
                data.m_position[1],
                data.m_position[2] );
        fprintf( m_file, "%f %f %f\t", 
                data.m_velocity[0],
                data.m_velocity[1],
                data.m_velocity[2] );
        fprintf( m_file,"%s\n",data.m_userData );
    }
    //*/
    /*
    //---------------------------------------------------------------
    // With data names
    for ( int i = 0; i < m_numData; ++i ) {
        SensAble_hduRecorderPacket & data = m_data[i];
        fprintf( m_file, "%d\t", i );
        fprintf( m_file, "Force: %f %f %f\t\t", 
                data.m_force[0],
                data.m_force[1],
                data.m_force[2] );
        fprintf( m_file,"Position: %f %f %f\t\t", 
                data.m_position[0],
                data.m_position[1],
                data.m_position[2] );
        fprintf( m_file, "Velocity: %f %f %f\t\t", 
                data.m_velocity[0],
                data.m_velocity[1],
                data.m_velocity[2] );
        fprintf( m_file,"%s\n",data.m_userData );
    }
    //*/
}

/******************************************************************************
 Scheduler callback; at each scheduler tick, add one tick's worth of data.
******************************************************************************/
HDCallbackCode HDCALLBACK SensAble_RecordLoopCallback ( 
    void * _SensAble_hduRecorder )
{
    SensAble_hduRecorder * pRecord = 
        ( SensAble_hduRecorder * ) _SensAble_hduRecorder;
    HDboolean bDone = pRecord->AddData();
    //---------------------------------------------------------------
    // If done, then create another thread to write out the data.
    if ( bDone ) {
#if defined( WIN32 )
        _beginthread( SensAble_RecordWriteCallback, 0, pRecord );
#elif defined(linux) || defined(__APPLE__)
        pthread_create( NULL, NULL, SensAble_RecordWriteCallback, pRecord );
#endif
        return HD_CALLBACK_DONE;
    }
    //---------------------------------------------------------------
    return HD_CALLBACK_CONTINUE;
}

/******************************************************************************
 Adds data for one tick.  Return true if done
******************************************************************************/
HDboolean SensAble_hduRecorder::AddData ()
{
    //---------------------------------------------------------------
    // Get the data and fill one packet.
    static SensAble_hduRecorderPacket data;
    hdGetDoublev( HD_CURRENT_FORCE,     data.m_force );
    hdGetDoublev( HD_CURRENT_POSITION,  data.m_position );
    hdGetDoublev( HD_CURRENT_VELOCITY,  data.m_velocity );
    data.m_userData = 0;
    if ( m_pUserCallback ) {
        char * userData = ( * m_pUserCallback )( m_pUserCallbackData );
        data.m_userData = userData;
    }
    //---------------------------------------------------------------
    // Either add the data to storage, or stop getting data 
    // if the recorder has received the amount specified.
    if ( m_index < m_numData ) {
        m_data[m_index] = data;
        ++m_index;
        return false;
    }
    else {
        return true;
    }
}

/******************************************************************************
 Create a recorder, start recording.  
******************************************************************************/
HDSchedulerHandle SensAble_hduStartRecord (
    FILE *              file,
    HDURecordCallback   pCallback,
    void *              pCallbackData,
    unsigned int        nData
)
{
    if ( !file ) {
        return false;
    }
    //-------------------------------------------
    SensAble_hduRecorder * pRecord = 
        new SensAble_hduRecorder(
                file,
                *pCallback,
                pCallbackData,
                nData );
    //-------------------------------------------
    if ( pRecord->Start() ) {
        return pRecord->GetShedulerHandle();
    }
    else {
        delete pRecord;
        return 0;
    }
}
/*****************************************************************************/
//=============================================================================
END_NAMESPACE_TAPs__Haptic
//-----------------------------------------------------------------------------
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----