avatar_sdk_sample.cpp

#include <avatar_sdk_sample.hpp>

#include <vector>

#if ANDROID
#include <android/log.h>
#define printf(...) __android_log_print(ANDROID_LOG_DEBUG, "AVATAR_SDK_SAMPLE", __VA_ARGS__)
#endif

std::vector<std::string> splitString(std::string& str, std::string separator)
{
    std::vector<std::string> result;
    size_t prevPos = 0, pos = 0;
    while ((pos = str.find(separator, pos)) != std::string::npos)
    {
        result.push_back(str.substr(prevPos, pos - prevPos));
        prevPos = ++pos;
    }
    result.push_back(str.substr(prevPos, pos - prevPos));
    return result;
}

std::string findGeneratedHaircutName(AvatarSdkPipelineSubtype pipelineSubtype)
{
    unsigned int haircutsStrSize = 0;
    const char* availableHaircuts = getAvailableHaircuts(pipelineSubtype, haircutsStrSize);
    std::string haircutsStr(availableHaircuts, haircutsStrSize);
    
    std::vector<std::string> haircuts = splitString(haircutsStr, ";");
    for (int i = 0; i < haircuts.size(); i++)
    {
        if (haircuts[i].find("generated") != std::string::npos)
            return haircuts[i];
    }
    return "";
}

int generateAvatarInStorage(AvatarSdkPipelineSubtype pipelineSubtype, std::string inputImagePath, std::string outputDirPath, std::string resourcesPath, ReportProgress progressCallback)
{
    // Initialize Avatar SDK
    int code = initAvatarSdk("Avatar SDK Sample", resourcesPath.c_str());
    if (code != 0)
    {
        printf("Unable to initialize Avatar SDK! \n");
        return code;
    }

    //Configure parameters
    AvatarSdkParams params;
    params.pipelineSubtype = pipelineSubtype;
    params.inputImagePath = (char*)inputImagePath.c_str();
    params.outputDirPath = (char*)outputDirPath.c_str();

    // Add one "generated" haircut
    std::string generatedHaircutName = findGeneratedHaircutName(pipelineSubtype);
    params.addHaircuts(generatedHaircutName.c_str(), generatedHaircutName.size());

    // Generate avatar
    code = generateAvatar(params,  progressCallback);
    if (code != 0)
        printf("Error occured during avatar generation!\n");
    else
        printf("Avatar was generated!\n");

    // Release Avatar SDK. Should be called after all avatars are generated.
    releaseAvatarSdk();
    return code;
}


int generateAvatarInMemory(AvatarSdkPipelineSubtype pipelineSubtype, std::string inputImagePath, std::string resourcesPath, ReportProgress progressCallback)
{
    // Initialize Avatar SDK
    int code = initAvatarSdk("Avatar SDK Sample", resourcesPath.c_str());
    if (code != 0)
    {
        printf("Unable to initialize Avatar SDK! \n");
        return code;
    }

    //Configure parameters
    AvatarSdkParams params;
    params.pipelineSubtype = pipelineSubtype;
    params.inputImagePath = (char*)inputImagePath.c_str();
    params.outputDirPath = NULL; // Set to NULL to store generated avatar in memory

    params.modelInfo = new AvatarSdkModelInfo();
    params.modelInfo->age = true;
    params.modelInfo->race = true;

    // Add one "generated" haircut
    std::string haircutName = findGeneratedHaircutName(pipelineSubtype);
    params.addHaircuts(haircutName.c_str(), haircutName.size());

    //Generate all available blendshapes
    unsigned int blendshapesStrSize = 0;
    const char* availableBlendshapes = getAvailableBlendshapes(pipelineSubtype, blendshapesStrSize);
    params.addBlendshapes(availableBlendshapes, blendshapesStrSize);

    // Generate avatar
    code = generateAvatar(params, progressCallback);
    if (code == 0)
    {
        printf("Avatar was generated!\n");

        //Get vertices
        int verticesCount = 0;
        const float* vertices = getAvatarVertices(verticesCount, NULL);

        //Get faces
        int facesCount = 0;
        const int* faces = getAvatarFaces(facesCount, NULL);
        const double* uvMapping = getAvatarUVMapping(facesCount, NULL);

        //Get texture
        int textureWidth, textureHeight;
        const unsigned char* texture = getAvatarTexture(textureWidth, textureHeight, NULL);

        //Get haircut vertices
        int haircutVerticesCount = 0;
        const float* haircutVertices = getHaircutVertices(haircutVerticesCount, haircutName.c_str(), nullptr); //nullptr for reading data from memory
        printf("There are %d vertices for haircut %s  stored in memory \n", haircutVerticesCount, haircutName.c_str());

        //Get haircut faces
        int haircutFacesCount = 0;
        const int* haircutFaces = getHaircutFaces(haircutFacesCount, haircutName.c_str(), nullptr); //nullptr for reading data from memory
        printf("There are %d faces for haircut %s stored in memory \n", haircutFacesCount, haircutName.c_str());

        //Get haircut texture
        int haircutTextureWidth, haircutTextureHeight;
        const unsigned char* haircutTexture = getHaircutTexture(haircutTextureWidth, haircutTextureHeight, haircutName.c_str(), nullptr);

        //Get "jawOpen" blendshape deltas
        std::string blendshapeName = "jawOpen";
        int blendshapeVerticesCount = 0;
        const float* verticesDeltas = getAvatarBlendshapeDeltas(blendshapeName.c_str(), blendshapeVerticesCount, nullptr);

        //Get model info
        AvatarSdkModelInfoEntry modelInfoEntry;
        getAvatarModelInfo(nullptr, modelInfoEntry); //nullptr for reading data from memory
        if (modelInfoEntry.age == AgePredicted::CHILD)
        {
            printf("Age: Child \n");
        }
        else if (modelInfoEntry.age == AgePredicted::NOT_CHILD)
        {
            printf("Age: Not child \n");
        }
        printf("Age confidence: %f \n", modelInfoEntry.ageConfidence);

        printf("Predicted race: %d\n", modelInfoEntry.race->predicted);
    }
    else
        printf("Error occured during avatar generation!\n");

    // Release Avatar SDK. Should be called after all avatars are generated.
    releaseAvatarSdk();
    return code;
}

void printResources(AvatarSdkResourcesList &resourcesList)
{
    for (unsigned int i = 0; i < resourcesList.length; i++)
    {
        printf("%d - %s : %s \n", i, resourcesList.resources[i].name, resourcesList.resources[i].path);
    }
}

int generateAvatarWithParameters(AvatarSdkPipelineSubtype subtype, std::string inputImagePath, std::string outputDirPath, std::string resourcesPath, ReportProgress progressCallback)
{
    //Initialize Avatar SDK with any application name
    int code = initAvatarSdk("Avatar SDK Sample", resourcesPath.c_str());
    if (code != 0)
    {
        printf("Unable to initialize Avatar SDK! \n");
        return code;
    }

    //Set parameters
    AvatarSdkParams avatarParams;
    avatarParams.pipelineSubtype = subtype;
    avatarParams.inputImagePath = (char*)inputImagePath.c_str();
    avatarParams.outputDirPath = (char*)outputDirPath.c_str();
    avatarParams.outputMeshFormat = AvatarSdkMeshFormat::AVATAR_SDK_MESH_FORMAT_OBJ;
    if (subtype == AvatarSdkPipelineSubtype::HEAD_MOBILE)
        avatarParams.lodNumber = 7;

    //configure data that should be generated for this avatar
    avatarParams.modelInfo = new AvatarSdkModelInfo();
    avatarParams.modelInfo->gender = true;
    avatarParams.modelInfo->eyeScleraColor = true;
    avatarParams.modelInfo->eyeIrisColor = true;
    avatarParams.modelInfo->skinColor = true;
    avatarParams.modelInfo->age = true;
    avatarParams.modelInfo->hairColor = true;
    avatarParams.modelInfo->race = true;
    avatarParams.modelInfo->predictHaircut = true;
    if (subtype == AvatarSdkPipelineSubtype::HEAD_MOBILE)
        avatarParams.modelInfo->facialLandmarks68 = true;

    //avatar modifications
    avatarParams.avatarModifications = new AvatarModifications();
    if (subtype == AvatarSdkPipelineSubtype::BUST_MOBILE)
        avatarParams.avatarModifications->curvedBottom = true;
    avatarParams.avatarModifications->removeSmile = true;
    avatarParams.avatarModifications->removeGlasses = true;
    avatarParams.avatarModifications->enhanceLighting = true;
    avatarParams.avatarModifications->setEyeIrisColor(0, 255, 0);
    avatarParams.avatarModifications->setEyeScleraColor(0, 0, 255);
    avatarParams.avatarModifications->setHairColor(0, 187, 255);

    unsigned int haircutsStrSize = 0;
    const char* availableHaircuts = getAvailableHaircuts(subtype, haircutsStrSize);
    printf("Available haircuts: %s\n", availableHaircuts);

    unsigned int blendshapesStrSize = 0;
    const char* availableBlendshapes = getAvailableBlendshapes(subtype, blendshapesStrSize);
    printf("Available blendshapes: %s\n", availableBlendshapes);

    avatarParams.addBlendshapes(availableBlendshapes, blendshapesStrSize);
    avatarParams.addHaircuts(availableHaircuts, haircutsStrSize);

    code = generateAvatar(avatarParams, progressCallback);
    if (code == 0)
    {
        printf("Avatar was generated!\n");
        AvatarSdkModelInfoEntry entry;

        code = getAvatarModelInfo(avatarParams.outputDirPath, entry);
        if (!code)
        {
            if (entry.age == AgePredicted::CHILD)
            {
                printf("Age: Child \n");
            }
            else if (entry.age == AgePredicted::NOT_CHILD)
            {
                printf("Age: Not child \n");
            }
            printf("Age confidence: %f \n", entry.ageConfidence);
            if (entry.skinColor)
            {
                printf("Skin color (RGB): %d %d %d \n", entry.skinColor->red, entry.skinColor->green, entry.skinColor->blue);
            }

            printf("Predicted race: %d\n", entry.race->predicted);
            printf("Predicted haircut: %s\n", entry.predictedHaircut);

            AvatarSdkResourcesList modelHaircuts = getAvatarHaircutsList(avatarParams.outputDirPath);
            AvatarSdkResourcesList modelBlendshapes = getAvatarBlendshapesList(avatarParams.outputDirPath);

            printf("Model's haircuts: \n");
            printResources(modelHaircuts);
            printf("Model's blendshapes: \n");
            printResources(modelBlendshapes);
        }
        else
        {
            printf("Error occured getting of model info!\n");
        }
    }
    else
    {
        printf("Unable to generate avatar. Error code: %d", code);
    }

    delete avatarParams.modelInfo;
    delete avatarParams.avatarModifications;

    // Release Avatar SDK. Should be called after all avatars are generated.
    releaseAvatarSdk();
    return code;
}

int generateCartoonishAvatar(AvatarSdkPipelineSubtype subtype, std::string inputImagePath, std::string outputDirPath, std::string resourcesPath, ReportProgress progressCallback)
{
    //Initialize Avatar SDK with any application name
    int code = initAvatarSdk("Avatar SDK Sample", resourcesPath.c_str());
    if (code != 0)
    {
        printf("Unable to initialize Avatar SDK! \n");
        return code;
    }

    //Set parameters
    AvatarSdkParams avatarParams;
    avatarParams.pipelineSubtype = subtype;
    avatarParams.inputImagePath = (char*)inputImagePath.c_str();
    avatarParams.outputDirPath = (char*)outputDirPath.c_str();
    avatarParams.outputMeshFormat = AvatarSdkMeshFormat::AVATAR_SDK_MESH_FORMAT_OBJ;

    // cartoonishLevel impacts on how much the geometry will be modified. It is applicable only to the head/mobile subtype
    if (subtype == AvatarSdkPipelineSubtype::HEAD_MOBILE)
        avatarParams.cartoonishLevel = 1.0f;

    //avatar modifications
    avatarParams.avatarModifications = new AvatarModifications();
    avatarParams.avatarModifications->slightlyCartoonishTexture = true;
    avatarParams.avatarModifications->parametricEyesTexture = true;
    avatarParams.avatarModifications->addGlare = true;
    avatarParams.avatarModifications->addEyelidShadow = true;

    // Add one "generated" haircut
    std::string haircutName = findGeneratedHaircutName(subtype);
    avatarParams.addHaircuts(haircutName.c_str(), haircutName.size());

    code = generateAvatar(avatarParams, progressCallback);
    if (code == 0)
    {
        printf("Cartoonsih avatar was generated!\n");
    }
    else
    {
        printf("Unable to generate cartoonish avatar. Error code: %d", code);
    }

    delete avatarParams.avatarModifications;

    // Release Avatar SDK. Should be called after all avatars are generated.
    releaseAvatarSdk();
    return code;
}