storytold/storyteller-ml
2
0
Fork 0
mirror of https://github.com/storytold/storyteller-ml.git synced 2026-10-18 00:33:15 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
0d662c5b9db6794253c97d939dc23c787ace951a
storyteller-ml/animation/MocapNET-kasisnu/src/MocapNET2/MocapNETLib2/solutionParts/body.cpp
T
Kasisnu 0d662c5b9d slightly tweaked mocapnet alt container
2024-01-18 19:24:33 +05:30

308 lines
20 KiB
C++
Raw Blame History

#include "body.hpp"
#include "../../MocapNETLib2/config.h"
#include "../../MocapNETLib2/IO/conversions.hpp"
#include "../../MocapNETLib2/tools.hpp"
#include "../../MocapNETLib2/core/core.hpp"
#define NORMAL "\033[0m"
#define BLACK "\033[30m" /* Black */
#define RED "\033[31m" /* Red */
#define GREEN "\033[32m" /* Green */
#define YELLOW "\033[33m" /* Yellow */
int mocapnetBody_initializeAssociations(struct MocapNET2 * mnet, struct skeletonSerialized * input)
{
return initializeAssociationsForSubsetOfSkeleton(
&mnet->bodySelectionIndexesArePopulated,
mnet->bodySelectionIndexes,
mocapNET_InputLength_WithoutNSDM_body,
mocapNET_body,
input
);
}
int mocapnetBody_initialize(struct MocapNET2 * mnet,const char * filename,float qualitySetting,unsigned int mode,unsigned int forceCPU)
{
char modelPath[1024]= {0};
int result = 0;
int modelNumber=0;
switch (mode)
{
case 3:
mnet->body.mode=3;
fprintf(stderr,RED "Fatal: Mode 3 No longer supported on MocapNET 2 \n" NORMAL);
exit(0);
break;
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
case 5:
mnet->body.mode=5;
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Regular 3 Model setup such as the BMVC 2019 Work..
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
snprintf(modelPath,1024,"dataset/combinedModel/mocapnet2/mode%u/%0.1f/categorize_body_all.pb",mode,qualitySetting);
if (fileExists(modelPath))
{
result += loadTensorflowInstance(&mnet->body.models[modelNumber] ,modelPath ,"input_all" ,"result_all/concat",forceCPU);
mnet->body.modelLimits[modelNumber].isFlipped=0;
mnet->body.modelLimits[modelNumber].numberOfLimits=1;
mnet->body.modelLimits[modelNumber].minimumYaw1=-360.0;
mnet->body.modelLimits[modelNumber].maximumYaw1=360.0;
modelNumber+=1;
} else
{
fprintf(stderr,YELLOW "Could not find a pose categorization classifier for Whole Body..\n " NORMAL );
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
snprintf(modelPath,1024,"dataset/combinedModel/mocapnet2/mode%u/%0.1f/body_front.pb",mode,qualitySetting);
result += loadTensorflowInstance(&mnet->body.models[modelNumber],modelPath,"input_front","result_front/concat",forceCPU);
mnet->body.modelLimits[modelNumber].isFlipped=0;
mnet->body.modelLimits[modelNumber].numberOfLimits=1;
mnet->body.modelLimits[modelNumber].minimumYaw1=-45.0;
mnet->body.modelLimits[modelNumber].maximumYaw1=45.0;
modelNumber+=1;
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
snprintf(modelPath,1024,"dataset/combinedModel/mocapnet2/mode%u/%0.1f/body_back.pb",mode,qualitySetting);
result += loadTensorflowInstance(&mnet->body.models[modelNumber],modelPath,"input_back","result_back/concat",forceCPU);
mnet->body.modelLimits[modelNumber].isFlipped=0;
mnet->body.modelLimits[modelNumber].numberOfLimits=1;
mnet->body.modelLimits[modelNumber].minimumYaw1=135.0;//-90.0;
mnet->body.modelLimits[modelNumber].maximumYaw1=225.0;//-270.0;
modelNumber+=1;
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
snprintf(modelPath,1024,"dataset/combinedModel/mocapnet2/mode%u/%0.1f/body_left.pb",mode,qualitySetting);
result += loadTensorflowInstance(&mnet->body.models[modelNumber] ,modelPath ,"input_left" ,"result_left/concat",forceCPU);
mnet->body.modelLimits[modelNumber].isFlipped=0;
mnet->body.modelLimits[modelNumber].numberOfLimits=1;
mnet->body.modelLimits[modelNumber].minimumYaw1=-135.0;
mnet->body.modelLimits[modelNumber].maximumYaw1=45.0;
modelNumber+=1;
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
snprintf(modelPath,1024,"dataset/combinedModel/mocapnet2/mode%u/%0.1f/body_right.pb",mode,qualitySetting);//
result += loadTensorflowInstance(&mnet->body.models[modelNumber] ,modelPath ,"input_right" ,"result_right/concat",forceCPU);
mnet->body.modelLimits[modelNumber].isFlipped=0;
mnet->body.modelLimits[modelNumber].numberOfLimits=1;
mnet->body.modelLimits[modelNumber].minimumYaw1=45.0;
mnet->body.modelLimits[modelNumber].maximumYaw1=135.0;
modelNumber+=1;
if(result==modelNumber) // make this 5
{
result=1;
mnet->body.loadedModels=modelNumber; //make this 5
}
else
{
result=0;
}
break;
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
default:
fprintf(stderr,RED "You requested a MocapNET configuration that is incorrect ( mode=%u )\n" NORMAL , mode);
return 0;
break;
};
if (result)
{
fprintf(stderr,"Caching networks after initialization to be ready for use..\n");
std::vector<float> emptyValues;
for (int i=0; i<MNET_BODY_IN_NUMBER; i++)
{
emptyValues.push_back(0.0);
}
//---------------------------------------------------
for (int i=0; i<mnet->body.loadedModels; i++ )
{
std::vector<float> prediction = predictTensorflow(&mnet->body.models[i],emptyValues);
if (prediction.size()>0)
{
fprintf(stderr, GREEN "Caching model %u (%s) was successful\n" NORMAL ,i,mnet->body.models[i].modelPath);
}
else
{
fprintf(stderr,RED "Caching model %u (%s) was unsuccessful\n" NORMAL,i,mnet->body.models[i].modelPath);
}
}
}
return result;
}
int mocapnetBody_unload(struct MocapNET2 * mnet)
{
unsigned int result=0;
for (int i=0; i<mnet->body.loadedModels; i++ )
{
result+=unloadTensorflow(&mnet->body.models[i]);
}
if (result==mnet->body.loadedModels) { result=1; } else
{ result=0; }
mnet->body.loadedModels=0;
return result;
}
std::vector<float> mocapnetBody_evaluateInput(struct MocapNET2 * mnet,struct skeletonSerialized * input)
{
mnet->body.positionalInput = deriveMocapNET2InputUsingAssociations(
mnet,
input,
&mnet->bodySelectionIndexesArePopulated,
mnet->bodySelectionIndexes,
mocapNET_InputLength_WithoutNSDM_body,
mocapNET_body,
0 // Enable to debug input
);
mnet->body.NSDM = bodyCreateNDSM(mnet->body.positionalInput,1/*NSDM Positional*/,0/*NSDM Angular */,1 /*Use Normalization*/);
mnet->body.neuralNetworkReadyInput.clear();
mnet->body.neuralNetworkReadyInput.insert(mnet->body.neuralNetworkReadyInput.end(),mnet->body.positionalInput.begin(), mnet->body.positionalInput.end());
mnet->body.neuralNetworkReadyInput.insert(mnet->body.neuralNetworkReadyInput.end(),mnet->body.NSDM.begin(), mnet->body.NSDM.end());
//----------------------------------------------------------------------------------------------
//The code block above should have done everything needed to make a 749 element vector
//If input is not correct then we should stop right here
//----------------------------------------------------------------------------------------------
if (mnet->body.neuralNetworkReadyInput.size()!=MNET_BODY_IN_NUMBER)
{
fprintf(stderr,RED "MocapNET: Incorrect size of MocapNET input .. \n" NORMAL);
std::vector<float> emptyResult;
return emptyResult;
}
int orientationReceived =localOrientationExtraction(&mnet->body,mnet->body.neuralNetworkReadyInput);
if (orientationReceived!=MOCAPNET_ORIENTATION_NONE)
{
mnet->orientation=orientationReceived;
mnet->orientationClassifications[0]= mnet->body.orientationClassifications[0];
mnet->orientationClassifications[1]= mnet->body.orientationClassifications[1];
mnet->orientationClassifications[2]= mnet->body.orientationClassifications[2];
mnet->orientationClassifications[3]= mnet->body.orientationClassifications[3];
}
//First run the network that can predict the orientation of the skeleton so we will use the correct
//network to get the full BVH result from it
//----------------------------------------------------------------------------------------------
std::vector<float> result = localExecution(
&mnet->body,
mnet->body.neuralNetworkReadyInput,
mnet->orientation,
NN_ORIENTATIONS_TRAINED_AROUND_ZERO_AND_REQUIRE_TRICK /*Body Requires orientation trick*/
);
mnet->body.result = result;
return result;
}
int mocapnetBody_fillResultVector(std::vector<float> &result ,std::vector<float> resultBody)
{
if (resultBody.size()==MOCAPNET_BODY_OUTPUT_NUMBER)
{ //This is output that targets the old body only armature..!
result[MOCAPNET_OUTPUT_HIP_XPOSITION]=resultBody[MOCAPNET_BODY_OUTPUT_HIP_XPOSITION];
result[MOCAPNET_OUTPUT_HIP_YPOSITION]=resultBody[MOCAPNET_BODY_OUTPUT_HIP_YPOSITION];
result[MOCAPNET_OUTPUT_HIP_ZPOSITION]=resultBody[MOCAPNET_BODY_OUTPUT_HIP_ZPOSITION];
result[MOCAPNET_OUTPUT_HIP_ZROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_HIP_ZROTATION];
result[MOCAPNET_OUTPUT_HIP_YROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_HIP_YROTATION];
result[MOCAPNET_OUTPUT_HIP_XROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_HIP_XROTATION];
result[MOCAPNET_OUTPUT_ABDOMEN_ZROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_ABDOMEN_ZROTATION];
result[MOCAPNET_OUTPUT_ABDOMEN_XROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_ABDOMEN_XROTATION];
result[MOCAPNET_OUTPUT_ABDOMEN_YROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_ABDOMEN_YROTATION];
result[MOCAPNET_OUTPUT_CHEST_ZROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_CHEST_ZROTATION];
result[MOCAPNET_OUTPUT_CHEST_XROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_CHEST_XROTATION];
result[MOCAPNET_OUTPUT_CHEST_YROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_CHEST_YROTATION];
result[MOCAPNET_OUTPUT_NECK_ZROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_NECK_ZROTATION];
result[MOCAPNET_OUTPUT_NECK_XROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_NECK_XROTATION];
result[MOCAPNET_OUTPUT_NECK_YROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_NECK_YROTATION];
result[MOCAPNET_OUTPUT_HEAD_ZROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_HEAD_ZROTATION];
result[MOCAPNET_OUTPUT_HEAD_XROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_HEAD_XROTATION];
result[MOCAPNET_OUTPUT_HEAD_YROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_HEAD_YROTATION];
result[MOCAPNET_OUTPUT_EYE_L_ZROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_EYE_L_ZROTATION];
result[MOCAPNET_OUTPUT_EYE_L_XROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_EYE_L_XROTATION];
result[MOCAPNET_OUTPUT_EYE_L_YROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_EYE_L_YROTATION];
result[MOCAPNET_OUTPUT_EYE_R_ZROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_EYE_R_ZROTATION];
result[MOCAPNET_OUTPUT_EYE_R_XROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_EYE_R_XROTATION];
result[MOCAPNET_OUTPUT_EYE_R_YROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_EYE_R_YROTATION];
result[MOCAPNET_OUTPUT_RSHOULDER_ZROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_RSHOULDER_ZROTATION];
result[MOCAPNET_OUTPUT_RSHOULDER_XROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_RSHOULDER_XROTATION];
result[MOCAPNET_OUTPUT_RSHOULDER_YROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_RSHOULDER_YROTATION];
result[MOCAPNET_OUTPUT_RELBOW_ZROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_RELBOW_ZROTATION];
result[MOCAPNET_OUTPUT_RELBOW_XROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_RELBOW_XROTATION];
result[MOCAPNET_OUTPUT_RELBOW_YROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_RELBOW_YROTATION];
result[MOCAPNET_OUTPUT_RHAND_ZROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_RHAND_ZROTATION];
result[MOCAPNET_OUTPUT_RHAND_XROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_RHAND_XROTATION];
result[MOCAPNET_OUTPUT_RHAND_YROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_RHAND_YROTATION];
result[MOCAPNET_OUTPUT_LSHOULDER_ZROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_LSHOULDER_ZROTATION];
result[MOCAPNET_OUTPUT_LSHOULDER_XROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_LSHOULDER_XROTATION];
result[MOCAPNET_OUTPUT_LSHOULDER_YROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_LSHOULDER_YROTATION];
result[MOCAPNET_OUTPUT_LELBOW_ZROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_LELBOW_ZROTATION];
result[MOCAPNET_OUTPUT_LELBOW_XROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_LELBOW_XROTATION];
result[MOCAPNET_OUTPUT_LELBOW_YROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_LELBOW_YROTATION];
result[MOCAPNET_OUTPUT_LHAND_ZROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_LHAND_ZROTATION];
result[MOCAPNET_OUTPUT_LHAND_XROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_LHAND_XROTATION];
result[MOCAPNET_OUTPUT_LHAND_YROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_LHAND_YROTATION];
result[MOCAPNET_OUTPUT_RHIP_ZROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_RHIP_ZROTATION];
result[MOCAPNET_OUTPUT_RHIP_XROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_RHIP_XROTATION];
result[MOCAPNET_OUTPUT_RHIP_YROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_RHIP_YROTATION];
result[MOCAPNET_OUTPUT_RKNEE_ZROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_RKNEE_ZROTATION];
result[MOCAPNET_OUTPUT_RKNEE_XROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_RKNEE_XROTATION];
result[MOCAPNET_OUTPUT_RKNEE_YROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_RKNEE_YROTATION];
result[MOCAPNET_OUTPUT_RFOOT_ZROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_RFOOT_ZROTATION];
result[MOCAPNET_OUTPUT_RFOOT_XROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_RFOOT_XROTATION];
result[MOCAPNET_OUTPUT_RFOOT_YROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_RFOOT_YROTATION];
result[MOCAPNET_OUTPUT_TOE1_2_R_ZROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_TOE1_2_R_ZROTATION];
result[MOCAPNET_OUTPUT_TOE1_2_R_XROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_TOE1_2_R_XROTATION];
result[MOCAPNET_OUTPUT_TOE1_2_R_YROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_TOE1_2_R_YROTATION];
result[MOCAPNET_OUTPUT_TOE5_3_R_ZROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_TOE5_3_R_ZROTATION];
result[MOCAPNET_OUTPUT_TOE5_3_R_XROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_TOE5_3_R_XROTATION];
result[MOCAPNET_OUTPUT_TOE5_3_R_YROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_TOE5_3_R_YROTATION];
result[MOCAPNET_OUTPUT_LHIP_ZROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_LHIP_ZROTATION];
result[MOCAPNET_OUTPUT_LHIP_XROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_LHIP_XROTATION];
result[MOCAPNET_OUTPUT_LHIP_YROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_LHIP_YROTATION];
result[MOCAPNET_OUTPUT_LKNEE_ZROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_LKNEE_ZROTATION];
result[MOCAPNET_OUTPUT_LKNEE_XROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_LKNEE_XROTATION];
result[MOCAPNET_OUTPUT_LKNEE_YROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_LKNEE_YROTATION];
result[MOCAPNET_OUTPUT_LFOOT_ZROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_LFOOT_ZROTATION];
result[MOCAPNET_OUTPUT_LFOOT_XROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_LFOOT_XROTATION];
result[MOCAPNET_OUTPUT_LFOOT_YROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_LFOOT_YROTATION];
result[MOCAPNET_OUTPUT_TOE1_2_L_ZROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_TOE1_2_L_ZROTATION];
result[MOCAPNET_OUTPUT_TOE1_2_L_XROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_TOE1_2_L_XROTATION];
result[MOCAPNET_OUTPUT_TOE1_2_L_YROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_TOE1_2_L_YROTATION];
result[MOCAPNET_OUTPUT_TOE5_3_L_ZROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_TOE5_3_L_ZROTATION];
result[MOCAPNET_OUTPUT_TOE5_3_L_XROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_TOE5_3_L_XROTATION];
result[MOCAPNET_OUTPUT_TOE5_3_L_YROTATION]=resultBody[MOCAPNET_BODY_OUTPUT_TOE5_3_L_YROTATION];
return 1;
} else
{
fprintf(stderr,YELLOW "MocapNET: Execution yielded %lu items ( expected %u ) for body don't know what to do with them.. \n" NORMAL,resultBody.size(),MOCAPNET_BODY_OUTPUT_NUMBER);
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink