// jscs:disable
import Ember from 'ember';
// http://stackoverflow.com/a/12646864
function shuffleArray(array) {
for (var i = array.length - 1; i > 0; i--) {
var j = Math.floor(Math.random() * (i + 1));
var temp = array[i];
array[i] = array[j];
array[j] = temp;
}
return array;
}
/**
* Select the first matching session from an array of options, according to the specified rules
*
* @method getLastSession
* @param {Session[]} pastSessions An array of session records. This returns the first match, eg assumes newest-first sort order
* @return {Session} The model representing the last session in which the user participated
*/
function getLastSession(pastSessions) {
// Base randomization on the newest (last completed) session for which the participant got at
// least as far as recording data for a single video ID.
for (let i = 0; i < pastSessions.length; i++) {
let session = pastSessions[i];
// Frames might be numbered differently in different experiments... rather than check for a frame ID, check that at least one frame referencing the videos exists at all.
let expData = session.get('expData') || {};
let keys = Object.keys(expData);
for (let i = 0; i < keys.length; i++) {
let frameKeyName = keys[i];
let frameData = expData[frameKeyName];
if (frameKeyName.indexOf('pref-phys-videos') !== -1 && frameData && frameData.videoId) {
return session;
}
}
}
// If no match found, explicitly return null
return null;
}
function getConditions(lastSession, frameId) {
var startType, showStay, whichObjects;
// The last session payload refers to the frame we want by number (#-frameName), but frames aren't numbered until the sequence
// has been resolved (eg until we expand pref-phys-videos into a series of video frames, we won't know how many
// frames there are or in what order)
// To find the last conditions, we take the last (and presumably only) key of session.conditions that looks like
// the name (without the leading number part)
// This works insofar as this function only targets one sort of frame that we expect to occur only once in
// the pref-phys experiment. Otherwise this function would get confused.
let lastConditions = lastSession ? lastSession.get('conditions') : null;
let lastFrameConditions;
Object.keys(lastConditions || {}).forEach((keyName) => {
if (keyName.indexOf(frameId) !== -1) {
lastFrameConditions = lastConditions[keyName];
}
});
if (!lastFrameConditions) {
startType = Math.floor(Math.random() * 4);
showStay = Math.floor(Math.random() * 2);
var whichObjectG = Math.floor(Math.random() * 6);
var whichObjectI = Math.floor(Math.random() * 6);
var whichObjectS = Math.floor(Math.random() * 6);
var whichObjectC = Math.floor(Math.random() * 6);
whichObjects = [whichObjectG, whichObjectI, whichObjectS, whichObjectC];
} else {
startType = lastFrameConditions.startType;
startType++;
if (startType > 3) {
startType = 0;
}
showStay = lastFrameConditions.showStay;
//parseInt(prompt('Show support-stay (1) or support-fall (0) last session?', '0/1'));
showStay = 1 - showStay;
whichObjects = Ember.copy(lastFrameConditions.whichObjects);
for (var i = 0; i < 4; i++) {
whichObjects[i]++;
if (whichObjects[i] > 5) {
whichObjects[i] = 0;
}
}
}
return {
startType: startType,
showStay: showStay,
whichObjects: whichObjects
};
}
function assignVideos(startType, showStay, whichObjects, NPERTYPE) {
// Types of comparisons for each event type (gravity, inertia, support-fall, support-stay,
// control). Format [event, outcomeMoreProb, outcomeLessProb]
const comparisonsG = [
['ramp', 'down', 'up'],
['ramp', 'down', 'up'],
['toss', 'down', 'up']
];
// TODO: Is this one still used?
const comparisonsI = [ // jshint ignore:line
['stop', 'hand', 'nohand'],
['reverse', 'barrier', 'nobarrier']
];
const comparisonsSF = [
['fall', 'slightly-on', 'mostly-on'],
['fall', 'next-to', 'mostly-on'],
['fall', 'near', 'mostly-on'],
['fall', 'next-to', 'slightly-on'],
['fall', 'near', 'slightly-on'],
['fall', 'near', 'next-to']
];
const comparisonsSS = [
['stay', 'slightly-on', 'mostly-on'],
['stay', 'next-to', 'mostly-on'],
['stay', 'near', 'mostly-on'],
['stay', 'next-to', 'slightly-on'],
['stay', 'near', 'slightly-on'],
['stay', 'near', 'next-to']
];
const comparisonsC = [
['same', 'A', 'B'],
['salience', 'interesting', 'boring']
];
// const videotypes = ['gravity', 'inertia', 'support', 'control'];
// FOR PILOT ONLY:
const videotypes = ['gravity', 'stay', 'control', 'fall'];
var compTypes = [comparisonsG, comparisonsSS, comparisonsC, comparisonsSF];
// how many times does each comparison type listed need to be shown to get to NPERTYPE for that event type?
var nReps = [2, 1, 3, 1];
/*
// Choose which videos to show for support
if (showStay === 0) {
videotypes[1] = 'fall';
compTypes[1] = comparisonsSF;
} else if (showStay === 1) {
videotypes[1] = 'stay';
compTypes[1] = comparisonsSS;
} /* else {
alert('invalid value for showStay (should be '0' or '1'), using '0'');
videotypes[2] = 'fall';
compTypes[2] = comparisonsSF;
} */
// Objects to use: elements correspond to videotypes
const physicalObjects = [
['apple', 'cup', 'whiteball', 'lotion', 'spray', 'whiteball'],
['hammer', 'tissues', 'duck', 'book', 'shoe', 'brush'],
['box', 'funnel', 'eraser', 'scissors', 'spoon', 'wrench'],
['hammer', 'tissues', 'duck', 'book', 'shoe', 'brush']
];
// Options for videos, organized by event
const cameraAngles = {
table: ['c1', 'c2'],
ramp: ['c1', 'c2'],
toss: ['c1', 'c2'],
stop: ['c1', 'c2'],
reverse: ['c1', 'c2'],
fall: ['c2'],
stay: ['c2'],
same: ['c1'],
salience: ['c1'],
};
const backgrounds = {
table: ['b1', 'b2'],
ramp: ['b1', 'b2'],
toss: ['b1'],
stop: ['b1'],
reverse: ['b1'],
fall: ['green'],
stay: ['green'],
same: ['b1'],
salience: ['b1']
};
const flips = {
table: ['NR'],
ramp: ['NN', 'RR', 'NR', 'RN'],
toss: ['NN', 'RR'],
stop: ['NR'],
reverse: ['RN'],
fall: ['NN', 'NR', 'RN', 'RR'],
stay: ['NN', 'NR', 'RN', 'RR'],
same: ['NN', 'RR', 'NR', 'RN'],
salience: ['NN', 'NR', 'RN', 'RR'],
};
// Create list of TYPES (e.g. gravity, inertia, ...)
var typeOrder = videotypes.slice(startType, videotypes.length);
typeOrder = typeOrder.concat(videotypes.slice(0, startType));
var playlistsByType = {};
for (var iType = 0; iType < videotypes.length; iType++) { // for each video type
// make list of objects to use with canonically-ordered comparison types
var objList = physicalObjects[iType].slice(whichObjects[iType], physicalObjects[iType].length);
objList = objList.concat(physicalObjects[iType].slice(0, whichObjects[iType]));
// make canonical comparison type list
var eventTypeList = compTypes[iType];
for (var iRep = 1; iRep < nReps[iType]; iRep++) {
eventTypeList = eventTypeList.concat(compTypes[iType]);
}
// choose placement of more/less surprising outcomes (balanced)
var onLeft = ['moreProb', 'moreProb', 'moreProb', 'lessProb', 'lessProb', 'lessProb'];
onLeft = shuffleArray(onLeft);
// pair objects and comparison types
var events = [];
for (var iEvent = 0; iEvent < eventTypeList.length; iEvent++) {
var outcomeL, outcomeR;
if (onLeft[iEvent] === 'moreProb') {
outcomeL = eventTypeList[iEvent][1];
outcomeR = eventTypeList[iEvent][2];
} else {
outcomeL = eventTypeList[iEvent][2];
outcomeR = eventTypeList[iEvent][1];
}
// choose camera angle, background, and NN/NR/RN/RR randomly
var iCamera = Math.floor(Math.random() *
cameraAngles[eventTypeList[iEvent][0]].length);
var iBackground = Math.floor(Math.random() *
backgrounds[eventTypeList[iEvent][0]].length);
var iFlip = Math.floor(Math.random() *
flips[eventTypeList[iEvent][0]].length);
events.push({
compType: eventTypeList[iEvent][0],
outcomeL: outcomeL,
outcomeR: outcomeR,
object: objList[iEvent],
camera: cameraAngles[eventTypeList[iEvent][0]][iCamera],
background: backgrounds[eventTypeList[iEvent][0]][iBackground],
flip: flips[eventTypeList[iEvent][0]][iFlip]
});
}
// choose order of events randomly
events = shuffleArray(events);
playlistsByType[videotypes[iType]] = events;
}
// Put list together
var allEvents = [];
var filenames = [];
var eventNum = 1;
for (var nEvents = 0; nEvents < NPERTYPE; nEvents++) {
for (iType = 0; iType < typeOrder.length; iType++) {
var e = playlistsByType[typeOrder[iType]][nEvents];
var fname = `sbs_${e.compType}_${e.outcomeL}_${e.outcomeR}_${e.object}_${e.camera}_${e.background}_${e.flip}`;
filenames.push(fname);
var altName = `sbs_${e.compType}_${e.outcomeR}_${e.outcomeL}_${e.object}_${e.camera}_${e.background}_${e.flip}`;
e.fname = fname;
e.altName = altName;
e.index = eventNum;
allEvents.push(e);
eventNum++;
}
}
return [allEvents, filenames];
}
function parse_name(fname) {
var pieces = fname.split('_');
var features = {};
features.eventType = pieces[1];
features.leftEvent = pieces[2];
features.rightEvent = pieces[3];
features.object = pieces[4];
features.camera = pieces[5];
features.bg = pieces[6];
var variantExt = pieces[7];
features.variant = (variantExt.split('.'))[0];
//quick hack for dummy clips which have wrong names for some objects
// (so we can get a correct intro name)
switch (features.object) {
case 'A':
features.object = 'box';
break;
case 'B':
features.object = 'eraser';
break;
case 'C':
features.object = 'funnel';
break;
case 'D':
features.object = 'scissors';
break;
case 'E':
features.object = 'spoon';
break;
case 'F':
features.object = 'wrench';
break;
}
return features;
}
function audioSourceObjs(path, shortname) {
return [
{
'src': path + shortname + '.ogg',
'type': 'audio/ogg'
},
{
'src': path + shortname + '.mp3',
'type': 'audio/mp3'
}
];
}
function videoSourceObjs(path, shortname, organizedByType) {
if (!organizedByType) {
return [
{
'src': path + shortname + '.webm',
'type': 'video/webm'
},
{
'src': path + shortname + '.mp4',
'type': 'video/mp4'
}
];
} else {
return [
{
'src': path + 'webm/' + shortname + '.webm',
'type': 'video/webm'
},
{
'src': path + 'mp4/' + shortname + '.mp4',
'type': 'video/mp4'
}
];
}
}
function toFrames(frameId, eventVideos, BASE_DIR) {
var nVideos = eventVideos.length;
return eventVideos.map((e) => {
if (e.index === nVideos) {
return {
kind: 'exp-video-physics',
id: `${frameId}`,
autoplay: true,
isLast: true,
audioSources: audioSourceObjs(
BASE_DIR + 'audio/',
'all_done'),
attnSources: videoSourceObjs(
BASE_DIR + 'stimuli/attention/',
'attentiongrabber'),
};
}
var features = parse_name(e.fname);
var allMusic = ['music_01', 'music_02', 'music_03', 'music_04', 'music_06', 'music_07', 'music_09', 'music_10'];
var musicName = allMusic[Math.floor(Math.random() * allMusic.length)];
var returnFrame = {
kind: 'exp-video-physics',
id: `${frameId}`,
autoplay: true,
testLength: 20, // TODO: change to 20s for actual testing.
isLast: false,
audioSources: audioSourceObjs(
BASE_DIR + 'audio/',
'video_' + ('00' + (e.index)).slice(-2)),
musicSources: audioSourceObjs(
BASE_DIR + 'audio/',
musicName),
introSources: videoSourceObjs(
BASE_DIR + 'stimuli/intro/',
`cropped_${features.object}`),
attnSources: videoSourceObjs(
BASE_DIR + 'stimuli/attention/',
'attentiongrabber'),
sources: videoSourceObjs(
BASE_DIR + 'stimuli/' + features.eventType + '/',
e.fname, true),
altSources: videoSourceObjs(
BASE_DIR + 'stimuli/' + features.eventType + '/',
e.altName, true)
};
// FOR PILOT ONLY: replace fall videos with calibration
if (e.compType === 'fall') {
returnFrame.sources = videoSourceObjs(
BASE_DIR + 'stimuli/attention/',
'calibration');
returnFrame.altSources = videoSourceObjs(
BASE_DIR + 'stimuli/attention/',
'calibration');
}
return returnFrame;
});
}
var randomizer = function (frameId, frameConfig, pastSessions, resolveFrame) {
var MAX_VIDEOS = 24; // limit number of videos. Use 24 for actual study.
var BASE_DIR = 'https://s3.amazonaws.com/lookitcontents/exp-physics/';
pastSessions.sort(function (a, b) {
return a.get('createdOn') > b.get('createdOn') ? -1 : 1;
});
// TODO: In the future, we may want to identify the specific frame # to fetch instead of generic frame name
pastSessions = pastSessions.filter(function (session) {
return session.get('conditions');
});
let lastSession = getLastSession(pastSessions);
var conditions = getConditions(lastSession, frameId);
conditions.NPERTYPE = 6;
var {
startType,
showStay,
whichObjects,
NPERTYPE
} = conditions;
var [eventVideos, ] = assignVideos(startType, showStay, whichObjects, NPERTYPE);
eventVideos = eventVideos.slice(0, MAX_VIDEOS);
eventVideos.push({index: MAX_VIDEOS + 1});
// allEvents and filenames are a function of conditions (no need to store)
var resolved = [];
toFrames(frameId, eventVideos, BASE_DIR).forEach((frame) => {
return resolved.push(...resolveFrame(null, frame)[0]);
});
return [resolved, conditions];
};
export default randomizer;
// Export helper functions to support unit testing
export { getConditions, getLastSession };
