//-*****************************************************************************
void testCyclicTime4()
{
const chrono_t startFrame = 1001.0;
const chrono_t ftime = 1.0 / 24.0;
const chrono_t timePerCycle = ftime;
const size_t numSamplesPerCycle = 3;
const size_t numSamps = 20;
const chrono_t first = ( startFrame * ftime ) - ( ftime / 4.0 );
const chrono_t second = startFrame * ftime;
const chrono_t third = ( startFrame * ftime ) + ( ftime / 4.0 );
TimeVector tvec;
tvec.push_back( first );
tvec.push_back( second );
tvec.push_back( third );
const AbcA::TimeSamplingType tst( numSamplesPerCycle, timePerCycle );
const AbcA::TimeSampling tsamp( tst, tvec );
TESTING_MESSAGE_ASSERT( tst.isCyclic(), "Should be cyclic." );
std::cout << "Testing cyclic time, 4" << std::endl;
validateTimeSampling( tsamp, tst, tvec, numSamplesPerCycle,
timePerCycle );
testTimeSampling( tsamp, tst, numSamps );
}
//-*****************************************************************************
void testAcyclicTime3()
{
TimeVector tvec;
// construct with acyclic enum
const chrono_t timePerCycle = AbcA::TimeSamplingType::AcyclicTimePerCycle();
const size_t numSamplesPerCycle =
AbcA::TimeSamplingType::AcyclicNumSamples();
const size_t numSamps = 79;
chrono_t ranTime = 0.0;
Imath::srand48( numSamps );
for ( size_t i = 0 ; i < numSamps ; ++i )
{
// sample randomly
ranTime += Imath::drand48() * (chrono_t)i;
tvec.push_back( ranTime );
}
AbcA::TimeSamplingType::AcyclicFlag acf = AbcA::TimeSamplingType::kAcyclic;
const AbcA::TimeSamplingType tSampTyp( acf );
const AbcA::TimeSampling tSamp( tSampTyp, tvec );
TESTING_MESSAGE_ASSERT( tSampTyp.isAcyclic(), "Should be acyclic." );
std::cout << "Testing acyclic time, 3" << std::endl;
validateTimeSampling( tSamp, tSampTyp, tvec, numSamplesPerCycle,
timePerCycle );
testTimeSampling( tSamp, tSampTyp, numSamps );
}
//-*****************************************************************************
void testAcyclicTime1()
{
TimeVector tvec;
// construct with explicit values
const chrono_t timePerCycle = AbcA::TimeSamplingType::AcyclicTimePerCycle();
const size_t numSamplesPerCycle =
AbcA::TimeSamplingType::AcyclicNumSamples();
const size_t numSamps = 44;
for ( size_t i = 0 ; i < numSamps ; ++i )
{
// sample once at each frame, starting at +0th frame
tvec.push_back( (chrono_t)i * ( 1.0 / 24.0 ) );
}
const AbcA::TimeSamplingType tSampTyp( AbcA::TimeSamplingType::kAcyclic );
const AbcA::TimeSampling tSamp( tSampTyp, tvec );
TESTING_MESSAGE_ASSERT( tSampTyp.isAcyclic(), "Should be acyclic." );
std::cout << "Testing acyclic time, 1" << std::endl;
validateTimeSampling( tSamp, tSampTyp, tvec, numSamplesPerCycle,
timePerCycle );
testTimeSampling( tSamp, tSampTyp, numSamps );
}
//-*****************************************************************************
void testCyclicTime2()
{
// shutter-open, shutter-close
TimeVector tvec;
tvec.push_back( -1.0 / 48.0 );
tvec.push_back( 1.0 / 48.0 );
const chrono_t timePerCycle = 3.0 / 48.0;
const size_t numSamplesPerCycle = 2;
const size_t numSamps = 43;
const AbcA::TimeSamplingType tSampTyp( numSamplesPerCycle, timePerCycle );
const AbcA::TimeSampling tSamp( tSampTyp, tvec );
TESTING_MESSAGE_ASSERT( tSampTyp.isCyclic(), "Should be cyclic." );
std::cout << "Testing cyclic time, 2" << std::endl;
validateTimeSampling( tSamp, tSampTyp, tvec, numSamplesPerCycle,
timePerCycle );
testTimeSampling( tSamp, tSampTyp, numSamps );
}
//-*****************************************************************************
void testCyclicTime1()
{
// random weird cycle
TimeVector tvec;
tvec.push_back( -0.7 );
tvec.push_back( -0.1 );
tvec.push_back( 0.2 );
const chrono_t timePerCycle = 1.0; // 0.1 more time than tvec[2] - tvec[0]
const size_t numSamplesPerCycle = 3;
const size_t numSamps = 97;
const AbcA::TimeSamplingType tSampTyp( numSamplesPerCycle, timePerCycle );
const AbcA::TimeSampling tSamp( tSampTyp, tvec );
TESTING_MESSAGE_ASSERT( tSampTyp.isCyclic(), "Should be cyclic." );
std::cout << "Testing cyclic time, 1" << std::endl;
validateTimeSampling( tSamp, tSampTyp, tvec, numSamplesPerCycle,
timePerCycle );
testTimeSampling( tSamp, tSampTyp, numSamps );
}
//-*****************************************************************************
void testDefaultTime1()
{
// sample once at each frame
TimeVector tvec;
AbcA::TimeSamplingType tSampType;
AbcA::TimeSampling tSamp;
tvec.push_back( 0.0 );
TESTING_MESSAGE_ASSERT( tSamp.getTimeSamplingType().isUniform(),
"Should be uniform." );
std::cout << "Testing default, 1" << std::endl;
validateTimeSampling( tSamp, tSampType, tvec, 1,
1 );
testTimeSampling( tSamp, tSampType, 100 );
}
//-*****************************************************************************
void testUniformTime3()
{
// sample once at each frame, starting at +1th frame
TimeVector tvec;
tvec.push_back( 2.0 / 24.0 );
const chrono_t timePerCycle = 1.0 / 24.0;
const size_t numSamplesPerCycle = 1;
const size_t numSamps = 49;
const AbcA::TimeSamplingType tSampTyp( numSamplesPerCycle, timePerCycle );
const AbcA::TimeSampling tSamp( tSampTyp, tvec );
TESTING_MESSAGE_ASSERT( tSampTyp.isUniform(), "Should be uniform." );
std::cout << "Testing uniform time, 3" << std::endl;
validateTimeSampling( tSamp, tSampTyp, tvec, numSamplesPerCycle,
timePerCycle );
testTimeSampling( tSamp, tSampTyp, numSamps );
}
