void Native::OneTimeInit( App *app, jclass mainActivityClass )
{
LOG( "Native::OneTimeInit" );
const double start = TimeInSeconds();
togglePlayingMethodId = GetMethodID( app, mainActivityClass, "togglePlaying", "()V" );
createVideoThumbnailMethodId = GetMethodID( app, mainActivityClass, "createVideoThumbnail", "(Ljava/lang/String;Ljava/lang/String;II)Z" );
checkForMovieResumeId = GetMethodID( app, mainActivityClass, "checkForMovieResume", "(Ljava/lang/String;)Z" );
startMovieMethodId = GetMethodID( app, mainActivityClass, "startMovieFromNative", "(Ljava/lang/String;Ljava/lang/String;ZZ)V" );
stopMovieMethodId = GetMethodID( app, mainActivityClass, "stopMovie", "()V" );
pauseMovieMethodId = GetMethodID( app, mainActivityClass, "pauseMovie", "()V" );
resumeMovieMethodId = GetMethodID( app, mainActivityClass, "resumeMovie", "()V" );
setPositionMethodId = GetMethodID( app, mainActivityClass, "setPosition", "(I)V" );
getPositionMethodId = GetMethodID( app, mainActivityClass, "getPosition", "()I" );
seekDeltaMethodId = GetMethodID( app, mainActivityClass, "seekDelta", "(I)V" );
showUIMethodId = GetMethodID( app, mainActivityClass, "showUI", "()V" );
hideUIMethodId = GetMethodID( app, mainActivityClass, "hideUI", "()V" );
isPlaybackFinishedMethodId = GetMethodID( app, mainActivityClass, "isPlaybackFinished", "()Z" );
hadPlaybackErrorMethodId = GetMethodID( app, mainActivityClass, "hadPlaybackError", "()Z" );
gazeCursorMethodId = GetMethodID( app, mainActivityClass, "gazeCursor", "(FFZZI)I" );
getPlaybackControlsRectMethodId = GetMethodID( app, mainActivityClass, "getPlaybackControlsRect", "()[I" );
LOG( "Native::OneTimeInit: %3.1f seconds", TimeInSeconds() - start );
}
float SleepUntilTimePoint( const double targetSeconds, const bool busyWait )
{
const float sleepSeconds = targetSeconds - TimeInSeconds();
if ( sleepSeconds > 0 )
{
if ( busyWait )
{
while( targetSeconds - TimeInSeconds() > 0 )
{
}
}
else
{
// I'm assuming we will never sleep more than one full second.
timespec t, rem;
t.tv_sec = 0;
t.tv_nsec = sleepSeconds * 1e9;
nanosleep( &t, &rem );
const double overSleep = TimeInSeconds() - targetSeconds;
if ( overSleep > 0.001 )
{
// LOG( "Overslept %f seconds", overSleep );
}
}
}
return sleepSeconds;
}
void ResumeMovieView::OneTimeInit( const char * launchIntent )
{
LOG( "ResumeMovieView::OneTimeInit" );
const double start = TimeInSeconds();
CreateMenu( Cinema.app, Cinema.app->GetVRMenuMgr(), Cinema.app->GetDefaultFont() );
LOG( "ResumeMovieView::OneTimeInit: %3.1f seconds", TimeInSeconds() - start );
}
void MoviePlayerView::OneTimeInit( const char * launchIntent )
{
LOG( "MoviePlayerView::OneTimeInit" );
const double start = TimeInSeconds();
GazeUserId = Cinema.app->GetGazeCursor().GenerateUserId();
CreateMenu( Cinema.app, Cinema.app->GetVRMenuMgr(), Cinema.app->GetDefaultFont() );
LOG( "MoviePlayerView::OneTimeInit: %3.1f seconds", TimeInSeconds() - start );
}
bool pixkit::Timer::Report(){
if (is_started){
printf("pixkit::timer '%s' is started.\n Cannot provide a time report.", title.c_str());
return false;
}
float timeUsed = TimeInSeconds();
printf("[%s] CumuTime: %4gs, #run: %4d, AvgTime: %4gs\n", title.c_str(), timeUsed, n_starts, timeUsed/n_starts);
return true;
}
//==============================
// OvrDefaultComponent::FocusLost
eMsgStatus OvrDefaultComponent::FocusLost( App * app, VrFrame const & vrFrame, OvrVRMenuMgr & menuMgr,
VRMenuObject * self, VRMenuEvent const & event )
{
// clear the hilight flag
self->SetHilighted( false );
StartFadeInTime = -1.0;
StartFadeOutTime = FadeDelay + TimeInSeconds();
return MSG_STATUS_ALIVE;
}
//==============================
// OvrDefaultComponent::FocusGained
eMsgStatus OvrDefaultComponent::FocusGained( App * app, VrFrame const & vrFrame, OvrVRMenuMgr & menuMgr,
VRMenuObject * self, VRMenuEvent const & event )
{
// set the hilight flag
self->SetHilighted( true );
GazeOverSoundLimiter.PlaySound( app, "sv_focusgained", 0.1 );
StartFadeOutTime = -1.0;
StartFadeInTime = FadeDelay + TimeInSeconds();
return MSG_STATUS_ALIVE;
}
/*
* Frame()
*
* App override
*/
Matrix4f MoviePlayerView::Frame( const VrFrame & vrFrame )
{
// Drop to 2x MSAA during playback, people should be focused
// on the high quality screen.
EyeParms eyeParms = Cinema.app->GetEyeParms();
eyeParms.multisamples = 2;
Cinema.app->SetEyeParms( eyeParms );
if ( Native::HadPlaybackError( Cinema.app ) )
{
LOG( "Playback failed" );
Cinema.UnableToPlayMovie();
}
else if ( Native::IsPlaybackFinished( Cinema.app ) )
{
LOG( "Playback finished" );
Cinema.MovieFinished();
}
CheckInput( vrFrame );
CheckDebugControls( vrFrame );
UpdateUI( vrFrame );
if ( Cinema.SceneMgr.FreeScreenActive && !MenuOpen )
{
Cinema.app->GetGuiSys().OpenMenu( Cinema.app, Cinema.app->GetGazeCursor(), "MoviePlayerMenu" );
MenuOpen = true;
}
else if ( !Cinema.SceneMgr.FreeScreenActive && MenuOpen )
{
Cinema.app->GetGuiSys().CloseMenu( Cinema.app, Menu, false );
MenuOpen = false;
}
if ( SeekSpeed != 0 )
{
const double now = TimeInSeconds();
if ( now > NextSeekTime )
{
int PlaybackSpeed = ( SeekSpeed < 0 ) ? -( 1 << -SeekSpeed ) : ( 1 << SeekSpeed );
PlaybackPos += 250 * PlaybackSpeed;
Native::SetPosition( Cinema.app, PlaybackPos );
NextSeekTime = now + 0.25;
}
}
return Cinema.SceneMgr.Frame( vrFrame );
}
//==============================
// OvrDefaultComponent::Frame
eMsgStatus OvrDefaultComponent::Frame( App * app, VrFrame const & vrFrame, OvrVRMenuMgr & menuMgr,
VRMenuObject * self, VRMenuEvent const & event )
{
double t = TimeInSeconds();
if ( StartFadeInTime >= 0.0f && t >= StartFadeInTime )
{
HilightFader.StartFadeIn();
StartFadeInTime = -1.0f;
}
else if ( StartFadeOutTime >= 0.0f && t > StartFadeOutTime )
{
HilightFader.StartFadeOut();
StartFadeOutTime = -1.0f;
}
float const fadeRate = 1.0f / FadeDuration;
HilightFader.Update( fadeRate, vrFrame.DeltaSeconds );
float const hilightAlpha = HilightFader.GetFinalAlpha();
Vector3f offset = HilightOffset * hilightAlpha;
self->SetHilightPose( Posef( Quatf(), offset ) );
int additiveSurfIndex = self->FindSurfaceWithTextureType( SURFACE_TEXTURE_ADDITIVE, true );
if ( additiveSurfIndex >= 0 )
{
Vector4f surfColor = self->GetSurfaceColor( additiveSurfIndex );
surfColor.w = hilightAlpha;
self->SetSurfaceColor( additiveSurfIndex, surfColor );
}
float const scale = ( ( HilightScale - 1.0f ) * hilightAlpha ) + 1.0f;
self->SetHilightScale( scale );
if ( SuppressText )
{
self->SetTextColor( Vector4f( 0.0f ) );
}
else
{
Vector4f colorDelta = TextHilightColor - TextNormalColor;
Vector4f curColor = TextNormalColor + ( colorDelta * hilightAlpha );
self->SetTextColor( curColor );
}
return MSG_STATUS_ALIVE;
}
PatcherOptions::PatcherOptions(int argc, char* argv[]) : m_displayHelp(false), m_displayVersion(false),
m_interactive(true), m_patchToRealLength(false), m_timeInSeconds(105),
m_lengthConditionType(condition_none), m_lengthCondition(120), m_startingPaths()
{
po::options_description desc = GetCmdOptions();
po::positional_options_description positionalOptions;
positionalOptions.add("patchpaths", -1);
po::variables_map vm;
po::store(po::command_line_parser(argc, argv).options(desc).positional(positionalOptions).run(), vm);
po::notify(vm);
DisplayHelp(vm.count("help") > 0);
DisplayVersion(vm.count("version") > 0);
Interactive(vm.count("not-interactive") == 0);
bool unpatch = vm.count("unpatch") > 0;
bool patchall = vm.count("patchall") > 0;
if(vm.count("patchpaths"))
{
SetStartingPaths(vm["patchpaths"].as<vector<string> >());
}
else
{
StartingPaths().push_back(fs::initial_path().string());
}
if(!unpatch)
{
TimeInSeconds(105);
UseLengthGreaterThanCondition(120);
}
else
{
PatchToRealLength();
UseLengthEqualCondition(105);
}
if(patchall)
{
DontUseLengthCondition();
}
}
void AppLocal::DrawDialog( const Matrix4f & mvp )
{
// draw the pop-up dialog
const float now = TimeInSeconds();
if ( now >= dialogStopSeconds )
{
return;
}
const Matrix4f dialogMvp = mvp * dialogMatrix;
const float fadeSeconds = 0.5f;
const float f = now - ( dialogStopSeconds - fadeSeconds );
const float clampF = f < 0.0f ? 0.0f : f;
const float alpha = 1.0f - clampF;
DrawPanel( dialogTexture->textureId, dialogMvp, alpha );
}
int main(int argc, char *argv[])
{
std::string PATH;
std::string OUTFILE;
if ((argc < 3) || (argc > 3))
{
//not enough arguments
std::cout << std::endl;
std::cout << "Not correct number of arguments provided - expect 2:" << std::endl;
std::cout << "\t1:\t \"input/directory/path/\" " << std::endl;
std::cout << "\t2:\t \"output-file-name.dat\" " << std::endl;
std::cout << std::endl;
return 1;
}
else
{
PATH = argv[1];
OUTFILE = argv[2];
}
std::cout << std::endl;
std::cout << "=================================" << std::endl;
std::cout << " Sandtray Log Analysis Programme" << std::endl;
std::cout << " P. Baxter, 2016" << std::endl;
std::cout << "=================================" << std::endl;
std::cout << std::endl;
//check for trailing forward slash on path, insert if there isn't one
if (PATH[PATH.size()-1] != '/')
{
PATH += '/';
}
std::string OUTPATH = PATH;
std::cout << std::endl;
std::cout << "PATH: \t" << PATH << std::endl;
std::cout << "Output file: \t" << OUTFILE << std::endl;
std::cout << std::endl;
////////////////////////////////////////
// PROCESSING THRESHOLDS
int MAX_REACTION = 60; //max time to wait (in s) before considering a reaction time to a prompt to be too large
/////////////////////////////////////////////////////////////////////////////////////////////////////
//step 0
// -- get list of directory names in the assigned directory
std::vector<std::string> dirNames;
dirNames.clear();
int dirCount = 0;
unsigned char isDir = 0x4; //use 0x8 for finding files
DIR *Folder;
struct dirent *FolderEntry;
Folder = opendir(PATH.c_str());
if (Folder)
{
std::cout << "Top level directory found:\t" << PATH << std::endl;
}
else
{
std::cout << "Cannot find top level directory:\t" << PATH << std::endl;
return 1;
}
while ((FolderEntry = readdir(Folder)))
{
if (FolderEntry->d_type == isDir)
{
//std::cout << "Found file: " << DirEntry->d_name << std::endl;
std::string name = FolderEntry->d_name;
if ((name == ".") || (name == ".."))
{
//don't include these in directory list
}
else
{
dirNames.push_back(name);
dirCount++;
}
}
}
std::cout << "Total number of directories found: " << dirCount << std::endl;
std::cout << std::endl;
//if no files, then don't bother continuing
if (dirCount == 0)
{
std::cout << "No directories found in selected top level directory, end of programme..." << std::endl;
std::cout << std::endl;
return 1;
}
//sort vector to make sure in correct order!
sort( dirNames.begin(), dirNames.end() );
std::cout << "List of directories to analyse:" << std::endl;
for (int fNum = 0; fNum < (int)dirNames.size(); fNum++)
{
std::cout << "\t" << dirNames[fNum] << std::endl;
}
std::cout << std::endl;
/////////////////////////////////////////////////////////////////////////////////////////////////////
// setting up variables to enable iterating through identified directories
std::vector<std::string> fileNames;
int fileCount = 0;
unsigned char isFile = 0x8; //use 0x4 for finding folders
//total intervention stats over all sessions
std::vector<int> IsectionTimes, InumLibraries, InumYourTurn, IchildMoves, IgoodChildMoves, IbadChildMoves, InumGoodFeedback, InumBadFeedback, IgoodRobotMoves, IbadRobotMoves, IreactionTimeN, ImoveSpeedN, IturntakingN;
std::vector<double> IpromptsPerMove, IreactionTimeM, IreactionTimeSD, ImoveSpeedM, ImoveSpeedSD, IturnTakingM, IturnTakingSD;
for (int numDir = 0; numDir < (int)dirNames.size(); numDir++)
{
std::cout << "*****************" << std::endl;
std::cout << " SESSION " << numDir+1 << std::endl;
std::cout << "****************" << std::endl;
std::string SUBPATH = PATH + dirNames[numDir] + "/";
/////////////////////////////////////////////////////////////////////////////////////////////////////
//step 1
// -- get list of filenames in the assigned directory
fileNames.clear();
fileCount = 0; //number of files in the directory
DIR *Dir;
struct dirent *DirEntry;
Dir = opendir(SUBPATH.c_str());
if (Dir)
{
std::cout << "Directory found" << std::endl;
std::cout << "\t" << SUBPATH << std::endl;
std::cout << std::endl;
}
else
{
std::cout << "Cannot open directory: " << std::endl;
std::cout << "\t" << SUBPATH << std::endl;
std::cout << std::endl;
return 1;
}
while ((DirEntry = readdir(Dir)))
{
if (DirEntry->d_type == isFile)
{
//std::cout << "Found file: " << DirEntry->d_name << std::endl;
fileNames.push_back(DirEntry->d_name);
fileCount++;
}
}
std::cout << "Total number of files found: " << fileCount << std::endl;
std::cout << std::endl;
//if no files, then don't bother continuing
if (fileCount == 0)
{
std::cout << "No files found in selected directory, end of programme..." << std::endl;
std::cout << std::endl;
return 1;
}
//add a check to remove all non-text files
std::string extension = ".txt";
std::vector<int> toRemove; //list to remove from file list
toRemove.clear();
for (int aa = 0; aa < (int)fileNames.size(); aa++)
{
//iterate through file names
std::size_t found = fileNames[aa].find(extension);
if (found == std::string::npos)
{
//substring not found, add to delete list
toRemove.push_back(aa);
}
}
//now remove the elements: START FROM BACK!
if ((int)toRemove.size() > 0)
{
for (int aaa = ((int)toRemove.size() - 1); aaa >= 0; aaa--)
{
fileNames.erase(fileNames.begin() + toRemove[aaa]);
}
}
//final check of file names to see what the contents of the file list is now
std::cout << "List of text files to analyse:" << std::endl;
for (int bb = 0; bb < (int)fileNames.size(); bb++)
{
std::cout << "\t" << fileNames[bb] << std::endl;
}
std::cout << std::endl;
/////////////////////////////////////////////////////////////////////////////////////////////////////
//step 1a
// -- set up variables to handle all session data across multiple files
//data collection
int goodChildMoves = 0;
int badChildMoves = 0;
int goodRobotMoves = 0;
int badRobotMoves = 0;
int startTime = 0;
int endTime = 0;
int timeOfLastPrompt = 0;
int lengthTime = 0;
int numYourTurn = 0;
int numMyTurn = 0;
int numGoodFeedback = 0;
int numBadFeedback = 0;
int numLibraries = 0;
//data containers
std::vector<int> reactionTime; //time between robot prompt and child move
reactionTime.clear();
std::vector<double> moveSpeeds; //speed of child moves
moveSpeeds.clear();
std::vector<double> turnTaking; //for each child move, whether turn taking happened
turnTaking.clear();
//more data containers
std::vector<int> sectionTimes;
sectionTimes.clear();
//loop variables
std::string readLine = "";
bool firstFlag = true;
bool endFlag = false;
bool promptFlag = false;
bool robotLastMove = false; //if robot was last to move, then this is true
int lineCounter = 0;
/////////////////////////////////////////////////////////////////////////////////////////////////////
//step 1b
// -- variable names for handling different file names
std::ifstream fileStream; //filestream to read from
char charFileName[512]; //very large just in case...
std::string fileName = ""; //name of the file to read from
/////////////////////////////////////////////////////////////////////////////////////////////////////
//step 2
// -- given each of the files in the directory in turn, open and process
for (int _counter = 0; _counter < fileCount; _counter++)
{
fileName = SUBPATH + fileNames[_counter]; //just the first file for now - increment for more than one file
char *a = new char[fileName.size()+1];
a[fileName.size()] = 0;
memcpy(a, fileName.c_str(), fileName.size());
strcpy (charFileName, a);
fileStream.open(charFileName, std::fstream::in); //open file stream for reading
delete a; //memory clean-up
//check file successfully opened before continuing
readLine = "";
if (fileStream.is_open())
{
std::cout << "*************************************************" << std::endl;
std::cout << "Opened file: " + fileName << std::endl;
//read file header
std::getline(fileStream, readLine); //first line is just headers
//only run this check on the first line
std::vector<std::string> splitLineF = Split(readLine,','); //split the line read in
if (splitLineF[0] != "Timestamp")
{
//if this is not true, then know that this is not a valid datafile...
std::cout << "ERROR: this file does not appear to be a valid data file: " + readLine << std::endl;
fileStream.close();
continue; //exit the while, go to next file...
}
}
else
{
//some error
std::cout << "ERROR reading file: " + fileName << std::endl;
fileStream.close();
return 1;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
//step 3
// -- extract data, process, add to global counters, then close file
//data collection
startTime = 0;
endTime = 0;
timeOfLastPrompt = 0;
lengthTime = 0;
//loop variables
readLine = "";
firstFlag = true;
endFlag = false;
promptFlag = false;
robotLastMove = false; //if robot was last to move, then this is true
lineCounter = 0;
while (std::getline(fileStream, readLine))
{
//read file until end
std::vector<std::string> splitLine = Split(readLine,','); //split the line read in
if (splitLine.size() < 3) //minimum of three elements to every line read from file
{
std::cout << "ERROR: problem reading line from file: " + readLine << std::endl;
continue; //skip to next while loop iteration
}
if (splitLine[1] == "SandtrayEvent") //////////////////// SANDTRAY EVENT
{
if (splitLine[2] == "i am a touchscreen")
{
//std::cout << "Time of touchscreen connect: " + splitLine[0] << std::endl;
}
else if (splitLine[2] == "22")
{ //library change
numLibraries++;
}
else if (splitLine[2] == "50")
{ //child good move
if(promptFlag == true) //if two child moves in a row, then don't count the time to second move...
{
int currTime = TimeInSeconds(splitLine[0]);
int elapsed = currTime - timeOfLastPrompt;
if (elapsed > MAX_REACTION)
{
//if more than a minute has passed, then beware!
std::cout << "*** Reaction time to robot prompt very high! Value: " << elapsed << std::endl;
//ignore this value...
}
else
{
reactionTime.push_back(elapsed);
}
promptFlag = false;
}
if (splitLine.size() >= 5)
{ //ensure that the container is at least this big, otherwise index errors
double speed = atof(splitLine[5].c_str());
moveSpeeds.push_back(speed);
}
if (robotLastMove == true)
{
turnTaking.push_back(1.0); //correct turn-taking
robotLastMove = false;
}
else
{
turnTaking.push_back(0.0); //bad turn-taking
robotLastMove = false;
}
goodChildMoves++;
}
else if (splitLine[2] == "51")
{ //child bad move
if(promptFlag == true) //if two child moves in a row, then don't count the time to second move...
{
int currTime = TimeInSeconds(splitLine[0]);
int elapsed = currTime - timeOfLastPrompt;
if (elapsed > MAX_REACTION)
{
//if more than a minute has passed, then beware!
std::cout << "*** Reaction time to robot prompt very high! Value: " << elapsed << std::endl;
//ignore this value
}
else
{
reactionTime.push_back(elapsed);
}
promptFlag = false;
}
if (splitLine.size() >= 5)
{ //ensure that the container is at least this big, otherwise index errors
double speed = atof(splitLine[5].c_str());
moveSpeeds.push_back(speed);
}
if (robotLastMove == true)
{
turnTaking.push_back(1.0); //correct turn-taking
robotLastMove = false;
}
else
{
turnTaking.push_back(0.0); //bad turn-taking
robotLastMove = false;
}
badChildMoves++;
}
else if (splitLine[2] == "52")
{ //robot bad move
badRobotMoves++;
robotLastMove = true; //only change flag after move has finished
}
else if (splitLine[2] == "53")
{ //robot good move
goodRobotMoves++;
robotLastMove = true; //only change flag after move has finished
}
}
else if (splitLine[1] == "SandtrayFeedback") //////////////////// SANDTRAY FEEDBACK
{
}
else if (splitLine[1] == "GUIcommand") //////////////////// GUI COMMAND
{
if (firstFlag == true)
{
if ((splitLine[3] == "your-turn") || (splitLine[3] == "my-turn") || (splitLine[3] == "good") || (splitLine[3] == "bad"))
{
//consider this to be the start of the interaction
startTime = TimeInSeconds(splitLine[0]);
std::cout << "Time of interaction start: " + splitLine[0] + "\t Seconds: " << startTime << std::endl;
firstFlag = false;
}
}
else //not the first time come across a GUIcommand
{
//std::cout << "GUI command requested: " + splitLine[3] + "\t at time " + splitLine[0] << std::endl;
if ((splitLine[2] == "behaviour") && (splitLine[3] == "stop"))
{
if (!endFlag)
{
//end time calculated outside of line read loop...
endFlag = true; //if have reached end, then don't look for more!
}
}
else if ((splitLine[2] == "behaviour") && (splitLine[3] == "your-turn"))
{
timeOfLastPrompt = TimeInSeconds(splitLine[0]);
numYourTurn++;
promptFlag = true;
//std::cout << "Robot prompt: " << promptFlag << std::endl;
}
else if ((splitLine[2] == "behaviour") && (splitLine[3] == "my-turn"))
{
numMyTurn++;
}
else if ((splitLine[2] == "behaviour") && (splitLine[3] == "bravo"))
{
numGoodFeedback++;
}
else if ((splitLine[2] == "behaviour") && (splitLine[3] == "bad"))
{
numBadFeedback++;
}
else if ((splitLine[2] == "move") && (splitLine[3] == "good"))
{
//goodRobotMoves++;
}
else if ((splitLine[2] == "move") && (splitLine[3] == "bad"))
{
//badRobotMoves++;
}
}
}
else if (splitLine[1] == "MotorFeedback") //////////////////// MOTOR FEEDBACK
{
//not doing anything with this at the moment
}
endTime = TimeInSeconds(splitLine[0]);
lineCounter++;
} //END OF WHILE LOOP
lengthTime = endTime - startTime;
if (lineCounter < 4)
{
//nothing happens in this file!
std::cout << "Nothing happens in this file!" << std::endl;
lengthTime = 0;
}
else if (startTime == 0)
{
//no event has occurred that is worth calling a start, therefore nothing of note happened!
std::cout << "No valid start event occurred in this file!" << std::endl;
lengthTime = 0;
}
fileStream.close();
/////////////////////////////////////////////////////////////////////////////////////////////////////
//step 4
// -- calculate overall session stats
std::cout << "----- End of file detected, total length (s): " << lengthTime << std::endl;
// -- store data for this session
sectionTimes.push_back(lengthTime);
} //END OF FILE PROCESSING FOR SINGLE FILE
/////////////////////////////////////////////////////////////////////////////////////////////////////
//step 5a
// -- write session stats to screen
/*std::cout << std::endl;
std::cout << std::endl;
std::cout << "TOTAL STATS:" << std::endl;
std::cout << std::endl;
std::cout << "Total interaction time: " << TotalInts(sectionTimes) << " sec" << std::endl;
std::cout << std::endl;
std::cout << "Num libraries used:\t" << numLibraries << std::endl;
std::cout << "Num robot prompts:\t" << numYourTurn << std::endl;
std::cout << "Tot num child moves:\t" << (goodChildMoves + badChildMoves) << std::endl;
std::cout << "Num good child moves:\t" << goodChildMoves << std::endl;
std::cout << "Num bad child moves:\t" << badChildMoves << std::endl;
std::cout << "Num prompts per move:\t" << ((double)numYourTurn / ((double)goodChildMoves + (double)badChildMoves)) << std::endl;
std::cout << std::endl;
std::cout << "Num good feedback:\t" << numGoodFeedback << std::endl;
std::cout << "Num bad feedback:\t" << numBadFeedback << std::endl;
std::cout << "Num robot good moves:\t" << goodRobotMoves << std::endl;
std::cout << "Num robot bad moves:\t" << badRobotMoves << std::endl;
std::cout << std::endl;
std::cout << "Mean reaction time:\t" << MeanOfInts(reactionTime) << "\t\tSD: " << SDofInts(reactionTime) << "\tN: " << (int)reactionTime.size() << std::endl;
std::cout << "Mean child move speed:\t" << MeanOfDoubles(moveSpeeds) << "\t\tSD: " << SDofDoubles(moveSpeeds) << "\tN: " << (int)moveSpeeds.size() << std::endl;
std::cout << "Mean child turn-taking:\t" << MeanOfDoubles(turnTaking) << "\tSD: " << SDofDoubles(turnTaking) << "\tN: " << (int)turnTaking.size() << std::endl;
std::cout << std::endl;*/
// -- for this session, put stats into relevant containers
IsectionTimes.push_back(TotalInts(sectionTimes));
InumLibraries.push_back(numLibraries);
InumYourTurn.push_back(numYourTurn);
IchildMoves.push_back((goodChildMoves + badChildMoves));
IgoodChildMoves.push_back(goodChildMoves);
IbadChildMoves.push_back(badChildMoves);
IpromptsPerMove.push_back(((double)numYourTurn / ((double)goodChildMoves + (double)badChildMoves)));
InumGoodFeedback.push_back(numGoodFeedback);
InumBadFeedback.push_back(numBadFeedback);
IgoodRobotMoves.push_back(goodRobotMoves);
IbadRobotMoves.push_back(badRobotMoves);
IreactionTimeM.push_back(MeanOfInts(reactionTime));
IreactionTimeSD.push_back(SDofInts(reactionTime));
IreactionTimeN.push_back((int)reactionTime.size());
ImoveSpeedM.push_back(MeanOfDoubles(moveSpeeds));
ImoveSpeedSD.push_back(SDofDoubles(moveSpeeds));
ImoveSpeedN.push_back((int)moveSpeeds.size());
IturnTakingM.push_back(MeanOfDoubles(turnTaking));
IturnTakingSD.push_back(SDofDoubles(turnTaking));
IturntakingN.push_back((int)turnTaking.size());
} //end of iterating through directories
std::cout << "*****************" << std::endl;
std::cout << " END OF ANALYSIS " << std::endl;
std::cout << "****************" << std::endl;
/////////////////////////////////////////////////////////////////////////////////////////////////////
//step 5a
// -- write session stats to file - at the moment one level up from the session data: OUTPATH
std::string filename = OUTPATH + OUTFILE;
std::ofstream outFile;
outFile.open(filename.c_str(), std::fstream::out);
//header
outFile << "Session,Interaction time (s),N_libraries,N_prompts,N_childMoves,N_goodChild,N_badChild,N_promptsPerMove,N_goodFeedback,N_badFeedback,N_goodRobot,N_badRobot,reactionTime,sd,n,childSpeed,sd,n,childTurnTaking,sd,n" << std::endl;
//data from the overall intervention containers
for (int s = 0; s < dirCount; s++)
{
outFile << dirNames[s] << "," << IsectionTimes[s] << "," << InumLibraries[s] << "," << InumYourTurn[s] << "," << IchildMoves[s] << "," << IgoodChildMoves[s] << "," << IbadChildMoves[s] << "," << IpromptsPerMove[s] << "," << InumGoodFeedback[s] << "," << InumBadFeedback[s] << "," << IgoodRobotMoves[s] << "," << IbadRobotMoves[s] << "," << IreactionTimeM[s] << "," << IreactionTimeSD[s] << "," << IreactionTimeN[s] << "," << ImoveSpeedM[s] << "," << ImoveSpeedSD[s] << "," << ImoveSpeedN[s] << "," << IturnTakingM[s] << "," << IturnTakingSD[s] << "," << IturntakingN[s] << std::endl;
}
outFile.close();
std::cout << "...end..." << std::endl;
return 0;
} //END OF MAIN
void AppLocal::DrawEyeViewsPostDistorted( Matrix4f const & centerViewMatrix, const int numPresents )
{
const float TEXT_SCALE = 1.0f;
// update vr lib systems after the app frame, but before rendering anything
GetGuiSys().Frame( this, vrFrame, GetVRMenuMgr(), GetDefaultFont(), GetMenuFontSurface() );
GetGazeCursor().Frame( this->lastViewMatrix, vrFrame.DeltaSeconds );
if ( ShowFPS )
{
static double LastFrameTime = TimeInSeconds();
static double AccumulatedFrameInterval = 0.0;
static int NumAccumulatedFrames = 0;
static float LastFrameRate = 60.0f;
double currentFrameTime = TimeInSeconds();
double frameInterval = currentFrameTime - LastFrameTime;
AccumulatedFrameInterval += frameInterval;
NumAccumulatedFrames++;
if ( NumAccumulatedFrames > FPS_NUM_FRAMES_TO_AVERAGE ) {
double interval = ( AccumulatedFrameInterval / NumAccumulatedFrames ); // averaged
AccumulatedFrameInterval = 0.0;
NumAccumulatedFrames = 0;
LastFrameRate = 1.0f / float( interval > 0.000001 ? interval : 0.00001 );
}
fontParms_t fontParms;
fontParms.CenterHoriz = true;
fontParms.Billboard = true;
fontParms.TrackRoll = true;
const Vector3f viewPos( GetViewMatrixPosition( centerViewMatrix ) );
const Vector3f viewFwd( GetViewMatrixForward( centerViewMatrix ) );
const Vector3f textPos( viewPos + viewFwd * 1.5f );
GetWorldFontSurface().DrawTextBillboarded3Df( GetDefaultFont(),
fontParms, textPos, TEXT_SCALE, Vector4f( 1.0f, 0.0f, 0.0f, 1.0f ), "%.1f fps", LastFrameRate );
LastFrameTime = currentFrameTime;
}
if ( InfoTextEndFrame >= vrFrame.FrameNumber )
{
fontParms_t fontParms;
fontParms.CenterHoriz = true;
fontParms.Billboard = true;
fontParms.TrackRoll = true;
const Vector3f viewPos( GetViewMatrixPosition( centerViewMatrix ) );
const Vector3f viewFwd( GetViewMatrixForward( centerViewMatrix ) );
const Vector3f textPos( viewPos + viewFwd * 1.5f );
GetWorldFontSurface().DrawTextBillboarded3Df( GetDefaultFont(),
fontParms, textPos, TEXT_SCALE, Vector4f( 1.0f, 1.0f, 1.0f, 1.0f ), InfoText.ToCStr() );
}
GetMenuFontSurface().Finish( centerViewMatrix );
GetWorldFontSurface().Finish( centerViewMatrix );
GetVRMenuMgr().Finish( centerViewMatrix );
// Increase the fov by about 10 degrees if we are not holding 60 fps so
// there is less black pull-in at the edges.
//
// Doing this dynamically based just on time causes visible flickering at the
// periphery when the fov is increased, so only do it if minimumVsyncs is set.
const float fovDegrees = hmdInfo.SuggestedEyeFov +
( ( ( SwapParms.MinimumVsyncs > 1 ) || ovr_GetPowerLevelStateThrottled() ) ? 10.0f : 0.0f ) +
( ( !showVignette ) ? 5.0f : 0.0f );
// DisplayMonoMode uses a single eye rendering for speed improvement
// and / or high refresh rate double-scan hardware modes.
const int numEyes = renderMonoMode ? 1 : 2;
// Flush out and report any errors
GL_CheckErrors("FrameStart");
if ( drawCalibrationLines && calibrationLinesDrawn )
{
// doing a time warp test, don't generate new images
LOG( "drawCalibrationLines && calibrationLinesDrawn" );
}
else
{
// possibly change the buffer parameters
EyeTargets->BeginFrame( vrParms );
for (int eye = 0; eye < numEyes; eye++)
{
EyeTargets->BeginRenderingEye( eye );
// Call back to the app for drawing.
const Matrix4f mvp = appInterface->DrawEyeView( eye, fovDegrees );
DrawActivity( mvp );
DrawPassThroughCamera( fovDegrees, vrFrame.PoseState.Pose.Orientation );
GetVRMenuMgr().RenderSubmitted( mvp.Transposed() );
GetMenuFontSurface().Render3D( GetDefaultFont(), mvp.Transposed() );
GetWorldFontSurface().Render3D( GetDefaultFont(), mvp.Transposed() );
glDisable( GL_DEPTH_TEST );
glDisable( GL_CULL_FACE );
// Optionally draw thick calibration lines into the texture,
// which will be overlayed by the thinner origin cross when
// distorted to the window.
if ( drawCalibrationLines )
{
EyeDecorations.DrawEyeCalibrationLines(fovDegrees, eye);
calibrationLinesDrawn = true;
}
else
{
calibrationLinesDrawn = false;
}
DrawDialog( mvp );
GetGazeCursor().Render( eye, mvp );
GetDebugLines().Render( mvp.Transposed() );
if ( showVignette )
{
// Draw a thin vignette at the edges of the view so clamping will give black
// This will not be reflected correctly in overlay planes.
// EyeDecorations.DrawEyeVignette();
EyeDecorations.FillEdge( vrParms.resolution, vrParms.resolution );
}
EyeTargets->EndRenderingEye( eye );
}
}
// This eye set is complete, use it now.
if ( numPresents > 0 )
{
const CompletedEyes eyes = EyeTargets->GetCompletedEyes();
for ( int eye = 0 ; eye < TimeWarpParms::MAX_WARP_EYES ; eye++ )
{
SwapParms.Images[eye][0].TexCoordsFromTanAngles = TanAngleMatrixFromFov( fovDegrees );
SwapParms.Images[eye][0].TexId = eyes.Textures[renderMonoMode ? 0 : eye ];
SwapParms.Images[eye][0].Pose = SensorForNextWarp.Predicted;
}
ovr_WarpSwap( OvrMobile, &SwapParms );
}
}
void MoviePlayerView::UpdateUI( const VrFrame & vrFrame )
{
// only show cursor when uiActive
if ( uiActive )
{
const Matrix4f screenModel = Cinema.app->GetActivityPanel().Matrix;
// -1 to 1 range on panelMatrix, returns -2,-2 if looking away from the panel
const Vector2f cursor = GazeCoordinatesOnPanel( Cinema.SceneMgr.Scene.CenterViewMatrix(), screenModel, Cinema.app->GetActivityPanel().AlternateGazeCheck );
const bool press = ( vrFrame.Input.buttonPressed & ( BUTTON_A | BUTTON_TOUCH ) ) != 0;
const bool release = ( ( vrFrame.Input.buttonReleased & ( BUTTON_A | BUTTON_TOUCH ) ) != 0 );
ePlaybackControlsEvent uiButtonPressed = ( ePlaybackControlsEvent )Native::GazeCursor( Cinema.app, (cursor.x * 0.5 + 0.5) * Cinema.app->GetActivityPanel().Width,
(0.5 - cursor.y * 0.5) * Cinema.app->GetActivityPanel().Height, press, release, SeekSpeed );
// don't register a button press if we just finished a swipe
if ( !( vrFrame.Input.buttonState & BUTTON_TOUCH_WAS_SWIPE ) )
{
switch( uiButtonPressed )
{
case UI_RW_PRESSED :
// rewind
Cinema.app->PlaySound( "touch_up" );
if ( SeekSpeed == 0 )
{
Native::PauseMovie( Cinema.app );
PlaybackPos = Native::GetPosition( Cinema.app );
}
SeekSpeed--;
if ( ( SeekSpeed == 0 ) || ( SeekSpeed < -MaxSeekSpeed ) )
{
SeekSpeed = 0;
Native::ResumeMovie( Cinema.app );
}
break;
case UI_PLAY_PRESSED :
// play/pause
Cinema.app->PlaySound( "touch_up" );
Native::TogglePlaying( Cinema.app );
SeekSpeed = 0;
break;
case UI_FF_PRESSED :
// fast forward
Cinema.app->PlaySound( "touch_up" );
if ( SeekSpeed == 0 )
{
Native::PauseMovie( Cinema.app );
PlaybackPos = Native::GetPosition( Cinema.app );
}
SeekSpeed++;
if ( ( SeekSpeed == 0 ) || ( SeekSpeed > MaxSeekSpeed ) )
{
SeekSpeed = 0;
Native::ResumeMovie( Cinema.app );
}
break;
case UI_CAROUSEL_PRESSED :
// movie select
Cinema.app->PlaySound( "touch_up" );
Cinema.MovieSelection( false );
break;
case UI_CLOSE_UI_PRESSED :
Cinema.app->PlaySound( "touch_up" );
HideUI();
Native::ResumeMovie( Cinema.app );
break;
case UI_USER_TIMEOUT :
HideUI();
Native::ResumeMovie( Cinema.app );
break;
case UI_SEEK_PRESSED :
PlaybackPos = Native::GetPosition( Cinema.app );
NextSeekTime = TimeInSeconds() + 0.25;
break;
default:
case UI_NO_EVENT :
break;
}
}
float cursorDistance = FLT_MAX;
eGazeCursorStateType cursorState = CURSOR_STATE_NORMAL;
if ( InsideUnit( cursor ) )
{
// FIXME: Project onto Free Screen
const Vector3f pos = screenModel.Transform( Vector3f( cursor.x, cursor.y, 0.0f ) );
cursorDistance = ( pos - Cinema.SceneMgr.Scene.CenterViewMatrix().GetTranslation() ).Length();
}
Cinema.app->GetGazeCursor().UpdateForUser( GazeUserId, cursorDistance, cursorState );
}
}
void MoviePlayerView::CheckInput( const VrFrame & vrFrame )
{
if ( !uiActive && !RepositionScreen )
{
if ( ( vrFrame.Input.buttonPressed & BUTTON_A ) || ( ( vrFrame.Input.buttonReleased & BUTTON_TOUCH ) && !( vrFrame.Input.buttonState & BUTTON_TOUCH_WAS_SWIPE ) ) )
{
// open ui if it's not visible
Cinema.app->PlaySound( "touch_up" );
ShowUI();
}
}
if ( vrFrame.Input.buttonPressed & ( BUTTON_DPAD_LEFT | BUTTON_SWIPE_BACK ) )
{
if ( ( vrFrame.Input.buttonPressed & BUTTON_DPAD_LEFT ) || !CursorInsidePlaybackControls() )
{
ShowUI();
if ( SeekSpeed == 0 )
{
Native::PauseMovie( Cinema.app );
PlaybackPos = Native::GetPosition( Cinema.app );
}
SeekSpeed--;
if ( ( SeekSpeed == 0 ) || ( SeekSpeed < -MaxSeekSpeed ) )
{
SeekSpeed = 0;
Native::ResumeMovie( Cinema.app );
}
Cinema.app->PlaySound( "touch_up" );
}
}
if ( vrFrame.Input.buttonPressed & ( BUTTON_DPAD_RIGHT | BUTTON_SWIPE_FORWARD ) )
{
if ( ( vrFrame.Input.buttonPressed & BUTTON_DPAD_RIGHT ) || !CursorInsidePlaybackControls() )
{
ShowUI();
if ( SeekSpeed == 0 )
{
Native::PauseMovie( Cinema.app );
PlaybackPos = Native::GetPosition( Cinema.app );
}
SeekSpeed++;
if ( ( SeekSpeed == 0 ) || ( SeekSpeed > MaxSeekSpeed ) )
{
SeekSpeed = 0;
Native::ResumeMovie( Cinema.app );
}
Cinema.app->PlaySound( "touch_up" );
}
}
if ( Cinema.SceneMgr.FreeScreenActive )
{
const Vector2f screenCursor = GazeCoordinatesOnPanel( Cinema.SceneMgr.Scene.CenterViewMatrix(), Cinema.SceneMgr.FreeScreenMatrix(), Cinema.app->GetActivityPanel().AlternateGazeCheck );
if ( !InsideUnit( screenCursor ) && !CursorInsidePlaybackControls() )
{
// outside of screen, so show reposition message
const double now = TimeInSeconds();
float alpha = MoveScreenAlpha.Value( now );
if ( alpha > 0.0f )
{
MoveScreenObj->RemoveFlags( VRMENUOBJECT_DONT_RENDER );
MoveScreenObj->SetTextColor( Vector4f( alpha ) );
}
if ( vrFrame.Input.buttonPressed & ( BUTTON_A | BUTTON_TOUCH ) )
{
RepositionScreen = true;
}
}
else
{
// onscreen, so hide message
const double now = TimeInSeconds();
MoveScreenAlpha.Set( now, -1.0f, now + 1.0f, 1.0f );
MoveScreenObj->AddFlags( VRMENUOBJECT_DONT_RENDER );
}
}
// while we're holding down the button or touchpad, reposition screen
if ( RepositionScreen )
{
if ( vrFrame.Input.buttonState & ( BUTTON_A | BUTTON_TOUCH ) )
{
Cinema.SceneMgr.PutScreenInFront();
}
else
{
RepositionScreen = false;
}
}
if ( vrFrame.Input.buttonPressed & BUTTON_START )
{
Native::TogglePlaying( Cinema.app );
SeekSpeed = 0;
}
if ( vrFrame.Input.buttonPressed & BUTTON_SELECT )
{
// movie select
Cinema.app->PlaySound( "touch_up" );
Cinema.MovieSelection( false );
}
if ( vrFrame.Input.buttonPressed & BUTTON_B )
{
if ( !uiActive )
{
BackPressed();
}
else
{
Cinema.app->PlaySound( "touch_up" );
HideUI();
Native::ResumeMovie( Cinema.app );
}
}
}
