Fg3CmdApply.cpp

//
// Copyright (c) Singular Inversions Inc. 2012
//
// Authors: Andrew Beatty
// Created: August 20, 2001.
//
// Construct 3D mesh and colour map from FG and SAM files
//
 
#include "stdafx.h"
 
#include "FgSerial.hpp"
#include "FgCommand.hpp"
#include "FgFileSystem.hpp"
#include "FgTime.hpp"
#include "Fg3dMeshIo.hpp"
#include "Fg3Sam.hpp"
#include "FgTestUtils.hpp"
#include "Fg3ImgIo.hpp"
#include "fimBmpIo.hpp"
#include "FgImageIo.hpp"
#include "FgApply.hpp"
#include "FgApply.hpp"
 
using namespace std;
 
namespace Fg {
 
void                cmd3ConstructSsm(CLArgs const & args)
{
    Syntax              syn {args,
        R"(<ssm> <face>.fg <out>.<ext>
    <ssm>       - <baseName> | <mesh>.<ext> <ssm>.egm
    <ext>       - )" + getMeshLoadExtsCLDescription() + R"(
OUTPUT:
    <out>.fgmesh        In the shape defined by <face>.fg
NOTES:
    If <baseName> is used, <baseName>.<ext> and <baseName>.egm must exist)"
    };
    Mesh                mesh;
    Ssm3                ssm;
    if (pathToExt(syn.next()).empty()) {
        mesh = loadMeshAnyFormat(syn.curr());
        ssm = Ssm3 {mesh.allVerts(),syn.curr()+".egm"};
    }
    else {
        mesh = loadMesh(syn.curr());
        ssm = Ssm3 {mesh.allVerts(),syn.next()};
    }
    Face3               face {syn.next()};
    {
        PushTimer           timer {"Construct SSM"};
        mesh.updateAllVerts(ssm.applyCoord(face.coord));
    }
    saveMesh(mesh,syn.next());
}
 
void                cmd3ConstructScm(CLArgs const & args)
{
    Syntax              syn {args,
        R"(<scm> <face>.fg <out>.<img> [-d <detailModulation>] [-g <gamma>] [-s]
    <scm>               - <baseName> | <base>.<img> <scm>.egt [<uvmap>.fim]
    <img>               - )" + clOptionsStr(getImgExts()) + R"(
    <detailModulation>  - [0.0,2.0] defaults to 1.0
    <gamma>             - [1.0,3.0] defaults to )" + toStr(Scm3::gammaDefault()) + R"(
    -s                  - single-threaded only (don't use multithreading)
OUTPUT:
    <out>.<img>     The color map for the given SCM part for the given face.
NOTES:
    * If <face>.fg contains a detail texture this will also be applied
    * Detail modulation allows you to increase or reduce the strength of this application
    * This command is only used on color maps containing skin)"
    };
    float               detailModulation = 1.0f;
    Scm3                scm;
    if (pathToExt(syn.next()).empty())
        scm = Scm3 {syn.curr()};
    else {
        string          imgFile = syn.curr(),
                        egtFile = syn.next(),
                        fimFile;
        if (toLower(pathToExt(syn.peekNext())) == "fim")
            fimFile = syn.next();
        scm = Scm3 {imgFile,egtFile,fimFile};
    }
    Face3               face {syn.next()};
    string              outFile = syn.next();
    bool                mt = true;
    while (syn.more()) {
        if (syn.next() == "-d") {
            detailModulation = syn.nextAs<float>();
            if ((detailModulation < 0.0f) || (detailModulation > 2.0f))
                syn.error("Invalid detailModulation value",syn.curr());
        }
        else if (syn.curr() == "-g") {
            float               gamma = syn.nextAs<float>();
            if ((gamma < 1.0f) || (gamma > 3.0f))
                syn.error("Invalid gamma value",syn.curr());
            scm.gamma = gamma;
        }
        else if (syn.curr() == "-s")
            mt = false;
        else
            syn.error("Unrecognized option",syn.curr());
    }
    ImgRgba8            outMap;
    {
        PushTimer           timer {"Construct SCM"};
        outMap = scm.applyFace(face,detailModulation,mt);
    }
    saveImage(outMap,outFile);
}
 
Cmd                 getCmd3ConstructSsm()
{
    return Cmd {cmd3ConstructSsm,"ssm","Apply a face to an SSM to create a mesh"};
}
 
Cmd                 getCmd3ConstructScm()
{
    return Cmd {cmd3ConstructScm,"scm","Apply a face to an SCM to create a color map"};
}
 
void                fg3RegressTri(const String & testn,const String & refn)
{
    testRegressApprox<Mesh>(
        loadTri(testn),
        refn,
        [](Mesh const & l,Mesh const & r){return isApproxEqualPrec(l.verts,r.verts); },
        loadMesh,
        [](Mesh const m,String8 const & f){saveTri(f,m); },
        isEqualSrlz<Mesh>);
}
 
void                testCmd3ConstructSsm(CLArgs const & args)
{
    FGTESTDIR;
    string          pfd = "csam/Preview/Face/";
    copyDataFileToCurr("main/John.fg");
    copyDataFileToCurr(pfd+"Face.tri");
    copyDataFileToCurr(pfd+"Face.egm");
    copyDataFileToCurr("csam/Animate/Hair/Short.tri");
    copyDataFileToCurr("csam/Animate/Hair/Short.egm");
    string          csj = "constructSiJohn.tri";
    runCmd(cmd3ConstructSsm,"ssm Face John.fg "+csj);
    fg3RegressTri(csj,"main/tests/"+csj);
    runCmd(cmd3ConstructSsm,"ssm Face.tri Face.egm John.fg "+csj);
    fg3RegressTri(csj,"main/tests/"+csj);
    runCmd(cmd3ConstructSsm,"ssm Short John.fg constructHairJohn.tri");
    fg3RegressTri("constructHairJohn.tri","main/tests/constructHairJohn.tri");
}
 
void                testCmd3ConstructScm(CLArgs const & args)
{
    FGTESTDIR;
    string      pfd = "csam/Preview/Face/";
    copyDataFileToCurr("main/John.fg");
    copyDataFileToCurr(pfd+"Face.png");
    copyDataFileToCurr(pfd+"Face.egt");
    copyDataFileToCurr(pfd+"Face.fim");
    string  csj = "constructSiJohn.png";
    runCmd(cmd3ConstructScm,"scm Face John.fg "+csj);
    regressImage(csj,"main/tests/",4);
    runCmd(cmd3ConstructScm,"scm Face.png Face.egt Face.fim John.fg "+csj);
    regressImage(csj,"main/tests/",4);
}
 
void                cmdApplyDaz(CLArgs const & args)
{
    Svec<DazGenesis>    dgi = cDazGenesisInfo();
    Strings             versions = mapMember(dgi,&DazGenesis::str);
    String              versionSyntax = "( " + cat(versions," | ") + " )";
    Syntax              syn {args,R"(<face>.fg <version> <gender> <dazLib> <name> [<img>+]
    <version>   - )" + versionSyntax + R"( corresponding to the Genesis version.
    <gender>    - (F | M) corresponding to female or male.
    <dazLib>    - Daz content library directory for output.
    <name>      - Output DSF and image files will start with this name.
    <img>+      - Base color map image files. If given they must be as follows:
                - G1: face, limbs, torso
                - G2: face, limbs, torso
                - G3: face, arms, legs, torso
                - G8: face, arms, legs, torso
                - G8.1: face, arms, body, head, legs
                - G9: head, arms, body, legs, eyes
NOTES:
    * <gender> is ignored for G9 which uses a gender-neutral mesh
    * morph controls will appear under the group name 'FaceGen')"
    };
    Face3               face {syn.next()};
    size_t              verIdx = findFirstIdx(dgi,syn.next());
    if (verIdx >= dgi.size())
        syn.error("not a valid Daz Genesis version number",syn.curr());
    DazGenesisVer       version = dgi[verIdx].ver;
    bool                female = (toLower(syn.next()) == "f");
    if (!female && (toLower(syn.curr()) != "m"))
        syn.error("not a valid gender",syn.curr());
    String8             dazLib = asDirectory(syn.next());
    String              outName = syn.next();
    String8s            baseMaps;
    while (syn.more())
        baseMaps.push_back(syn.next());
    if (version == DazGenesisVer::G9) {
        PushIndent          pind {"Writing files:"};
        dazExportShapeG9(face.coord,dazLib,"/FaceGen",outName);
        if (!baseMaps.empty()) {
            if (baseMaps.size() != 5)
                syn.error("G9 requires 5 base maps; Head, Arms, Body, Legs, Eyes");
            dazExportColorG9(face.coord,face.detail,dazLib,baseMaps,"/FaceGen",outName,false,{});
        }
    }
    else {              // versions 1 through 8.1:
        Strings             bodyMaps = dazGenesisBodyMapNames(version);
        if ((!baseMaps.empty()) && (baseMaps.size() != bodyMaps.size()+1))
            syn.error("Incorrect number of maps","face,"+cat(bodyMaps,","));
        dazExport(version,female,dazLib,face.coord,face.detail,true,"/FaceGen",outName,baseMaps,{});
    }
}
 
void                testDaz81(CLArgs const &)
{
    TestDir             td {"fg3-daz-81"};
    copyDataFileToCurr("main/John.fg");
    copyDataFileToCurr("artist/daz/Genesis81F/daz_arms.jpg");
    copyDataFileToCurr("artist/daz/Genesis81F/daz_body.jpg");
    copyDataFileToCurr("artist/daz/Genesis81F/daz_eyes.jpg");
    copyDataFileToCurr("artist/daz/Genesis81F/daz_face.jpg");
    copyDataFileToCurr("artist/daz/Genesis81F/daz_head.jpg");
    copyDataFileToCurr("artist/daz/Genesis81F/daz_legs.jpg");
    runCmd(cmdApplyDaz,"daz John.fg 81 f . test daz_face.jpg daz_arms.jpg daz_body.jpg daz_head.jpg daz_legs.jpg");
}
 
void                testDaz9(CLArgs const &)
{
    TestDir             td {"fg3-daz-9"};
    copyDataFileToCurr("main/John.fg");
    String              dufRelDir = "/People/Genesis 9/Materials/Daz Originals/Base Materials/";
    String8             dazContentDir = getDazContentDirContaining(dufRelDir + "G9 Feminine Skin 01 MAT.duf");
    if (dazContentDir.empty()) {        // not found, can only test morph
        runCmd(cmdApplyDaz,"daz John.fg 9 f . test");
    }
    else {
        String8             mapBase = dazContentDir+"Runtime/Textures/DAZ/Characters/Genesis9/Base/Feminine_01/G9Feminine01_";
        copyFile(mapBase+"Head_D_1001.jpg","Head.jpg");
        copyFile(mapBase+"Arms_D_1004.jpg","Arms.jpg");
        copyFile(mapBase+"Body_D_1002.jpg","Body.jpg");
        copyFile(mapBase+"Legs_D_1003.jpg","Legs.jpg");
        copyFile(dataDir()+"artist/daz/Genesis9/G9_Eyes03_D.jpg","Eyes.jpg");
        runCmd(cmdApplyDaz,"daz John.fg 9 f . test Head.jpg Arms.jpg Body.jpg Legs.jpg Eyes.jpg");
    }
}
 
void                testDaz(CLArgs const & args)
{
    Cmds                cmds {
        {testDaz81,"81","Genesis 8.1"},
        {testDaz9,"9","Genesis 9"},
    };
    doMenu(args,cmds,true);
}
 
void                testCmdApply(CLArgs const & args)
{
    Cmds                cmds {
        {testDaz,"daz"},
        {testCmd3ConstructScm,"scm"},
        {testCmd3ConstructSsm,"ssm"},
    };
    doMenu(args,cmds,true);
}
 
void                cmdApplyDna(CLArgs const & args)
{
    Syntax              syn {args,R"(<face>.fg <in>.dna <out>.dna
OUTPUT:
    <out>.dna       - <in>.dna with vertex positions adjusted to the shape of <face>.fg)"
    };
    Face3               face = loadFg(syn.next());
    Bytes               dna = loadRaw(syn.next());
    String              outfile = syn.next();
    Meshes              meshes = dnaImport(dna);
    size_t              M = meshes.size();
    String8             dd = dataDir()+"artist/dna/";
    Mesh                lmsMesh = loadMesh(dd+"lms-nrr.fgmesh");
    FaceLmPos3Fs        lmsBase = toFaceLmPoss(lmsMesh.markedVertsAsNameVecs());
    Ssm3                lmsSsm {lmsMesh.verts,dd+"lms-nrr.egm"};
    Arr<ScaleTrans3F,2> eyeXfs = cEyesTransform(lmsBase,lmsSsm.applyCoord(face.coord));
    Ssm3s               ssms = dsrlz<Ssm3s>(loadRaw(dd+"mean.Ssm3s"));
    FGASSERT(ssms.size() == M);
    Vec3Fss             shapes; shapes.reserve(M);
    for (size_t mm=0; mm<M; ++mm) {
        Mesh const &        mesh = meshes[mm];
        Ssm3 const &        ssm = ssms[mm];
        if (containsSubstr(mesh.name.m_str,"eyeLeft"))
            shapes.push_back(mapMul(eyeXfs[0],ssm.meanVerts));
        else if (containsSubstr(mesh.name.m_str,"eyeRight"))
            shapes.push_back(mapMul(eyeXfs[1],ssm.meanVerts));
        else
            shapes.push_back(ssm.applyCoord(face.coord));
    }
    dnaInject_(shapes,dna);
    saveRaw(dna,outfile);
}
 
void                cmdApplyIris(CLArgs const & args)
{
    Syntax              syn {args,R"(<face>.fg <color>.<img> <region>.<img> <output>.<img>
    <color>.<img>   - The color map for the face which contains the irises
    <region>.<img>  - Greyscale image [0,255] with same layout and aspect ratio as <color> defining iris area (=255)
    <img>           - )" + clOptionsStr(getImgExts()) + R"(
OUTPUT:
    <output>.<img>  - The <region> area of <color> is adjusted to match the iris color of <face>)"
    };
    Face3               face = loadFg(syn.next());
    ImgRgba8            color = loadImage(syn.next());
    ImgUC               region = toUC(loadImage(syn.next()));
    String              outName = syn.next();
    String8             dd = dataDir() + "photofit/si";
    Scm3                fgScm {dd};
    ImgRgba8            fgColor = fgScm.applyFace(face);
    ImgUC               fgRegion = toUC(loadImage(dataDir()+"photofit/si-iris-sample.png"));
    Arr3D               clr = sampleColor(color,region),
                        fgClr = sampleColor(fgColor,fgRegion);
    shiftColor_(fgClr-clr,region,color);
    saveImage(color,outName);
}
 
void                cmdApply(CLArgs const & args)
{
    Cmds            cmds {
        {cmdApplyDaz,"daz","Apply a face to Daz Studio Genesis meshes"},
        {cmdApplyDna,"dna","Apply a face to an Epic Metahuman DNA file"},
        {cmdApplyIris,"iris","Apply a face's iris color to a color map"},
        {getCmd3ConstructScm()},
        {getCmd3ConstructSsm()},
        {cmdScm3Base,"scmBase","Apply custom base textures to the SCMs of a body"},
    };
    doMenu(args,cmds);
}
 
}