int rec(const string &s) {
StringIntMap::const_iterator it = M.find(s);
if (it != M.end()) {
return it->second;
}
char temp[64];
strcpy(temp, s.c_str());
char *fg = strchr(temp, 'G');
char *rr = strrchr(temp, 'R');
int f = 0;
int r = 0;
if (rr > fg) {
if (fg != NULL) {
*fg = 'R';
f = rec(temp) + 1;
*fg = 'G';
}
if (rr != NULL) {
*rr = 'G';
r = rec(temp) + 1;
}
}
int result = min(f, r);
M[s] = result;
return result;
}
int minPaints(string row) {
char temp[64] = {0};
strcpy(temp, row.c_str());
char *fg = strchr(temp, 'G');
char *fr = strchr(temp, 'R');
char *rr = strrchr(temp, 'R');
if (fg == NULL) {
return 0;
}
if (fr == NULL) {
return 0;
}
if (rr < fg) {
return 0;
}
M.clear();
return rec(row);
}
ForceValidationResult* ValidateOpenMMForces::compareForce(Context& context, std::vector<int>& compareForces,
Platform& platform1, Platform& platform2 ) const {
// ---------------------------------------------------------------------------------------
//static const std::string methodName = "ValidateOpenMMForces::compareForce";
// ---------------------------------------------------------------------------------------
// note if platforms are identical
if( getLog() && platform1.getName().compare( platform2.getName() ) == 0 ){
(void) fprintf( getLog(), "Note: Platforms to compares %s are identical.\n", platform1.getName().c_str() );
(void) fflush( getLog() );
}
const System& system = context.getSystem();
// collect systemForceNameMap[forceName] = index in system
// systemForceNameIndex[index] = force name
StringIntMap systemForceNameMap;
StringVector systemForceNameIndex;
systemForceNameIndex.resize( system.getNumForces() );
for( int ii = 0; ii < system.getNumForces(); ii++ ){
std::string forceName = getForceName( system.getForce( ii ) );
if( forceName.compare( "NA" ) == 0 ){
std::stringstream message;
message << "Force at index=" << ii << " not found -- aborting!";
std::cerr << message.str() << std::endl;
throw OpenMM::OpenMMException(message.str());
}
systemForceNameMap[forceName] = ii;
systemForceNameIndex[ii] = forceName;
}
// diagnostics
if( 0 && getLog() ){
for( StringIntMapI ii = systemForceNameMap.begin(); ii != systemForceNameMap.end(); ii++ ){
int index = (*ii).second;
(void) fprintf( getLog(), " System force map %s index=%d reverse map=%s\n", (*ii).first.c_str(), index, systemForceNameIndex[index].c_str() );
}
for( unsigned int ii = 0; ii < compareForces.size(); ii++ ){
(void) fprintf( getLog(), " ValidateOpenMMForces %u %s\n", ii, systemForceNameIndex[compareForces[ii]].c_str() );
}
(void) fflush( getLog() );
}
// get system copy and add forces to system
System* validationSystem = copySystemExcludingForces( system );
StringUIntMap forceNamesMap;
for( unsigned int ii = 0; ii < compareForces.size(); ii++ ){
const Force& forceToCopy = system.getForce( compareForces[ii] );
Force* force = copyForce( forceToCopy );
validationSystem->addForce( force );
forceNamesMap[systemForceNameIndex[compareForces[ii]]] = ii;
}
// include any missing dependencies (e.g, OBC force requires NB force for Cuda platform)
for( StringUIntMapI ii = forceNamesMap.begin(); ii != forceNamesMap.end(); ii++ ){
std::string forceName = (*ii).first;
StringVector dependencyVector;
getForceDependencies( forceName, dependencyVector );
for( unsigned int jj = 0; jj < dependencyVector.size(); jj++ ){
std::string dependentForceName = dependencyVector[jj];
StringUIntMapCI dependent = forceNamesMap.find( dependentForceName );
if( dependent == forceNamesMap.end() ){
forceNamesMap[dependentForceName] = 1;
int forceIndex = systemForceNameMap[dependentForceName];
const Force& forceToCopy = system.getForce( forceIndex );
validationSystem->addForce( copyForce( forceToCopy ) );
}
}
}
// create contexts
VerletIntegrator verletIntegrator( 0.001 );
Context* validationContext1 = new Context( *validationSystem, verletIntegrator, platform1);
Context* validationContext2 = new Context( *validationSystem, verletIntegrator, platform2);
// set positions
synchContexts( context, *validationContext1 );
synchContexts( context, *validationContext2 );
// diagnostics
if( 0 && getLog() ){
std::stringstream forceNames;
(void) fprintf( getLog(), " Validating system forces=%d\n", validationSystem->getNumForces() );
for( int ii = 0; ii < validationSystem->getNumForces(); ii++ ){
std::string forceName = getForceName( validationSystem->getForce( ii ) );
forceNames << forceName;
if( ii < (validationSystem->getNumForces()-1) ){
forceNames << "_";
} else {
forceNames << "Parameters.txt";
}
(void) fprintf( getLog(), " force %d %s\n", ii, forceName.c_str() );
}
writeParameterFile( *validationContext1, forceNames.str() );
(void) fflush( getLog() );
}
// calculate forces & build return result
ForceValidationResult* forceValidationResult = new ForceValidationResult( *validationContext1, *validationContext2, forceNamesMap );
delete validationContext1;
delete validationContext2;
delete validationSystem;
return forceValidationResult;
}
bool AnimationExport::exportController()
{
vector<Niflib::ControllerLink> blocks = seq->GetControlledBlocks();
int nbones = skeleton->m_bones.getSize();
if (AnimationExport::noRootSiblings)
{
// Remove bones not children of root. This is a bit of a kludge.
// Basically search for the first node after the root which also has no parent
// This is typically Camera3. We then truncate tracks to exclude nodes appearing after.
for (int i=1; i<nbones; ++i)
{
if (skeleton->m_parentIndices[i] < 0)
{
nbones = i;
break;
}
}
}
int numTracks = nbones;
float duration = seq->GetStopTime() - seq->GetStartTime();
int nframes = (int)roundf(duration / FramesIncrement);
int nCurrentFrame = 0;
hkRefPtr<hkaInterleavedUncompressedAnimation> tempAnim = new hkaInterleavedUncompressedAnimation();
tempAnim->m_duration = duration;
tempAnim->m_numberOfTransformTracks = numTracks;
tempAnim->m_numberOfFloatTracks = 0;//anim->m_numberOfFloatTracks;
tempAnim->m_transforms.setSize(numTracks*nframes, hkQsTransform::getIdentity());
tempAnim->m_floats.setSize(tempAnim->m_numberOfFloatTracks);
tempAnim->m_annotationTracks.setSize(numTracks);
hkArray<hkQsTransform>& transforms = tempAnim->m_transforms;
typedef map<string, int, ltstr> StringIntMap;
StringIntMap boneMap;
for (int i=0; i<nbones; ++i)
{
string name = skeleton->m_bones[i].m_name;
boneMap[name] = i;
}
for ( vector<Niflib::ControllerLink>::iterator bitr = blocks.begin(); bitr != blocks.end(); ++bitr)
{
StringIntMap::iterator boneitr = boneMap.find((*bitr).nodeName);
if (boneitr == boneMap.end())
{
Log::Warn("Unknown bone '%s' found in animation. Skipping.", (*bitr).nodeName.c_str());
continue;
}
int boneIdx = boneitr->second;
hkQsTransform localTransform = skeleton->m_referencePose[boneIdx];
FillTransforms(transforms, boneIdx, nbones, localTransform); // prefill transforms with bindpose
if ( NiTransformInterpolatorRef interpolator = DynamicCast<NiTransformInterpolator>((*bitr).interpolator) )
{
if (NiTransformDataRef data = interpolator->GetData())
{
if ( data->GetTranslateType() == Niflib::LINEAR_KEY )
{
vector<Vector3Key> keys = data->GetTranslateKeys();
int n = keys.size();
if (n > 0)
{
int frame = 0;
float currentTime = 0.0f;
Vector3Key* itr = &keys[0], *last = &keys[n-1];
SetTransformPositionRange(transforms, nbones, boneIdx, currentTime, (*itr).time, frame, *itr, *itr);
for (int i=1; i<n; ++i)
{
Vector3Key* next = &keys[i];
SetTransformPositionRange(transforms, nbones, boneIdx, currentTime, (*next).time, frame, *itr, *next);
itr = next;
}
SetTransformPositionRange(transforms, nbones, boneIdx, currentTime, duration, frame, *last, *last);
}
}
else
{
Log::Verbose("Missing transform data for %s", boneitr->first.c_str());
}
if ( data->GetRotateType() == Niflib::QUADRATIC_KEY )
{
vector<QuatKey> keys = data->GetQuatRotateKeys();
int n = keys.size();
if (n > 0)
{
int frame = 0;
float currentTime = 0.0f;
QuatKey* itr = &keys[0], *last = &keys[n-1];
SetTransformRotationRange(transforms, nbones, boneIdx, currentTime, itr->time, frame, *itr, *itr);
for (int i=1; i<n; ++i)
{
QuatKey* next = &keys[i];
SetTransformRotationRange(transforms, nbones, boneIdx, currentTime, next->time, frame, *itr, *next);
itr = next;
}
SetTransformRotationRange(transforms, nbones, boneIdx, currentTime, duration, frame, *last, *last);
}
}
else
{
Log::Verbose("Missing rotation data for %s", boneitr->first.c_str());
}
if ( data->GetScaleType() == Niflib::LINEAR_KEY )
{
vector<FloatKey> keys = data->GetScaleKeys();
int n = keys.size();
if (n > 0)
{
int frame = 0;
float currentTime = 0.0f;
FloatKey* itr = &keys[0], *last = &keys[n-1];
SetTransformScaleRange(transforms, nbones, boneIdx, currentTime, itr->time, frame, *itr, *itr);
for (int i=1; i<n; ++i)
{
FloatKey* next = &keys[i];
SetTransformScaleRange(transforms, nbones, boneIdx, currentTime, next->time, frame, *itr, *next);
itr = next;
}
SetTransformScaleRange(transforms, nbones, boneIdx, currentTime, duration, frame, *last, *last);
}
}
else
{
Log::Verbose("Missing scaling data for %s", boneitr->first.c_str());
}
}
else
{
}
}
else
{
}
}
hkaSkeletonUtils::normalizeRotations (transforms.begin(), transforms.getSize());
// create the animation with default settings
{
hkaSplineCompressedAnimation::TrackCompressionParams tparams;
hkaSplineCompressedAnimation::AnimationCompressionParams aparams;
tparams.m_rotationTolerance = 0.001f;
tparams.m_rotationQuantizationType = hkaSplineCompressedAnimation::TrackCompressionParams::THREECOMP40;
hkRefPtr<hkaSplineCompressedAnimation> outAnim = new hkaSplineCompressedAnimation( *tempAnim.val(), tparams, aparams );
binding->m_animation = outAnim;
}
return true;
}
