Fg3Cmd.cpp

//
// Copyright (c) Singular Inversions Inc. 2014
//
// Authors: Andrew Beatty
// Created: Jan 2, 2014
//
 
#include "stdafx.h"
 
#include "FgCommand.hpp"
 
#include "FgMain.hpp"
#include "FgTestUtils.hpp"
#include "FgBuild.hpp"
#include "Fg3Face.hpp"
#include "Fg3dMeshIo.hpp"
#include "Fg3Sam.hpp"
#include "Fg3Freeform.hpp"
#include "FgParse.hpp"
#include "FgApply.hpp"
 
using namespace std;
 
namespace Fg {
 
void                cmd3DetailExtract(CLArgs const & args)
{
    Syntax              syn {args,
        R"(<face>.fg <modulationImage>.<ext>
    <ext>       - )" + clOptionsStr(getImgExts()) + R"(
OUTPUT:
    <modulationImage>
NOTES:
    * The modulation images are multiplicative (not additive) modifiers which add detail to the
      smooth maps created by FaceGen SCMs.
    * The modulation images are encoded as greyscale images, 8 bits/channel, with the multiplicative
      value given as X / 64.0
    * The UV layout of the modulation images is the FaceGen internal cylindrical layout. An SCM
      .fim file contains the transform from this layout into the UV layout of the SCM.)"
    };
    Face3               face {syn.next()};
    ImgRgba8            img;
    face.getDetail(img);
    saveImage(img,syn.next());
}
 
void                cmd3DetailInsert(CLArgs const & args)
{
    Syntax              syn {args,
        R"( <modulationImage>.<ext> <face>.fg
    <ext>       - )" + clOptionsStr(getImgExts()) + R"(
OUTPUT:
    modifies <face>.fg
NOTES:
    * The modulation images are multiplicative (not additive) modifiers which add detail to the
      smooth maps created by FaceGen SCMs.
    * The modulation images are encoded as greyscale images, 8 bits/channel, with the multiplicative
      value given as X / 64.0
    * The UV layout of the modulation images is the FaceGen internal cylindrical layout. An SCM
      .fim file contains the transform from this layout into the UV layout of the SCM.)"
    };
    String8             imgFname = syn.next(),
                        faceFname = syn.next();
    ImgRgba8            img = loadImage(imgFname);
    Face3               face {faceFname};
    if (img.width() != img.height())
        fgThrow("The detail texture image must be square",imgFname);
    if (!isPow2(img.width()))
        fgThrow("The detail texture image dimension must be a power of 2");
    face.detail = encodeJpeg(img,100);
    face.save(faceFname);
}
 
void                cmd3DetailRemove(CLArgs const & args)
{
    Syntax              syn{args,R"(<in>.fg <out>.fg
OUTPUT:
    <out>.fg is <in>.fg without the detail modulation map)"
    };
    Face3               face {syn.next()};
    if (face.detail.empty())
        fgout << "WARNING: " << syn.curr() << "has no detail map";
    face.detail.clear();
    face.save(syn.next());
}
 
void                cmd3Detail(CLArgs const & args)
{
    Cmds                tests {
        {cmd3DetailExtract,"extract","extract the detail modulation map from a .FG file"},
        {cmd3DetailInsert,"insert","insert a detail modulation map into a .FG file"},
        {cmd3DetailRemove,"remove","remove a detail modulation map from a .FG file"},
    };
    doMenu(args,tests,true,false);
}
 
void                cmd3Interactive(CLArgs const & args)
{
    Syntax          syn {args,
        R"((symm | asym) <ssm> <vertexIndex> <vertexDelta> <in>.fg <out>.fg
    <vertexDelta>   - <deltaX> <deltaY> <deltaZ>
OUTPUT:
    <out>.fg        Face with modified shape
NOTES:
    * Actual vertex deformation values will always be smaller than the length of <vertexDelta>,
      depending on the correlation between the given vertex motion and the shape basis.
)"
    };
    if (args.size() != 9)
        syn.errorNumArgs();
    string          symmStr(syn.next());
    string          ssmStr(syn.next());
    uint            vertexIndex = syn.nextAs<uint>();
    Vec3F           vertexDelta;
    vertexDelta[0] = syn.nextAs<float>();
    vertexDelta[1] = syn.nextAs<float>();
    vertexDelta[2] = syn.nextAs<float>();
    string          inFgStr(syn.next());
    string          outFgStr(syn.next());
    if ((symmStr != "symm") && (symmStr != "asym"))
        syn.error("Invalid symmetry specification");
    FanSymmE        symmetry = (symmStr == "symm") ? FANSYMM_SYMM : FANSYMM_ASYM;
    Mesh            mesh = loadTri(ssmStr+".tri");
    Ssm3            ssm(mesh.verts,ssmStr+".egm");
    Face3           face(inFgStr);
    fg3Interactive(face.coord,symmetry,ssm,vertexIndex,vertexDelta);
    face.save(outFgStr);
}
 
void                test3Controls(CLArgs const &);
void                testCmd3ConstructScm(CLArgs const &);
void                testCmd3ConstructSsm(CLArgs const &);
void                test3FaceCoord(CLArgs const &);
void                testCmdApply(CLArgs const &);
void                test3GetDetail(CLArgs const &);
void                testScm3(CLArgs const &);
 
void                test3Main(CLArgs const & args)
{
    Cmds                tests {
        {testCmdApply,"apply","test 'fg3 apply' command"},
        {test3Controls,"controls"},
        {test3FaceCoord,"coord"},
        {test3GetDetail,"getDetail"},
        {testScm3,"scm"},
    };
    doMenu(args,tests,true,false);
}
 
void                cmdEgmImport(CLArgs const & args)
{
    Syntax              syn {args,R"(<mean>.<ext> <modes>.txt <out>.egm
    <mean>          - the base mesh in the mean shape
    <ext>           - )" + getMeshLoadExtsCLDescription() + R"(
    <modes>.txt     - list of the filenames for each mode represented as a mesh with shape given by base + mode.
                      the filenames must have one of the recognized mesh extensions listed above.
    <out>.egm       - the modes are converted to the FaceGen 3 internal format
NOTES
    All modes are interpreted as symmetric shape modes.)"
    };
    Mesh                base = loadMesh(syn.next());
    Strings             modeFiles = splitWhitespace(loadRawString(syn.next()));
    Vec3Fss             modes;
    for (String const & mf : modeFiles) {
        Vec3Fs              verts = loadMesh(mf).verts;
        if (verts.size() != base.verts.size())
            syn.error("base and mode meshes must have identical size vertex lists");
        modes.push_back(verts-base.verts);
    }
    saveEgm(syn.next(),modes,{});
}
 
void                cmd3Basis3dmm(CLArgs const &);
void                cmd3BasisEgm(CLArgs const &);
void                cmd3BasisEgt(CLArgs const &);
void                cmdEgmVariances(CLArgs const &);
 
void                cmd3Basis(CLArgs const & args)
{
    Cmds            cmds {
        {cmd3Basis3dmm,"3dmm","Export from an .EGM file to a 3DMM .MatV3F file"},
        {cmd3BasisEgm,"egm","Export from an .EGM file to .TXT files"},
        {cmd3BasisEgt,"egt","Export from an .EGT file to .TXT files"},
        {cmdEgmImport,"import","Import linear shape modes from a base mesh and meshes representing each mode"},
        {cmdEgmVariances,"var","Print out the squared magnitude of each mode in an .EGM file"},
    };
    doMenu(args,cmds);
}
 
void                cmdApply(CLArgs const &);
void                cmd3Controls(CLArgs const &);
void                cmd3Coord(CLArgs const &);
void                cmd3Create(CLArgs const &);
void                cmd3Random(CLArgs const &);
void                cmd3Util(CLArgs const &);
void                cmd3View(CLArgs const &);
 
Cmds                getFg3Cmds()
{
    return {
        {cmdApply,"apply","Apply a face (.fg) to SAMs to create meshes and color maps"},
        {cmd3Basis,"basis","Import / export SAM basis modes"},
        {cmd3Controls,"controls","Parametric controls on face coordinates (.fg)"},
        {cmd3Coord,"coord","list / set face coordinates (.fg)"},
        {cmd3Create,"create","Create random or average faces (.fg)"},
        {cmd3Detail,"detail","Extract/insert a detail texure from/to an .FG file"},
        {cmd3Interactive,"interactive","Apply interactive deformations to an SSM and face coordinate"},
        {cmd3Random,"random","Batch create random face images"},
        {test3Main,"test","Automated tests"},
        {cmd3Util,"util","Utility functions"},
        {cmd3View,"view","interactive GUI view of SAMs, FG files, FIM files (Windows only)"},
    };
}
 
void                cmdFg3(CLArgs const & args)
{
    if (args.size() == 1)
        fgout << fgnl << "FaceGen Main SDK CLI " << getSdkVersion(".") << " (" << getCurrentBuildDescription() << ")"; 
    doMenu(args,getFg3Cmds(),false,true);
}
 
}