Fg3CmdUtil.cpp

//
// Copyright (c) Singular Inversions Inc. 2011
//
// Authors: Andrew Beatty
// Created: October 3, 2011
//
 
#include "stdafx.h"
 
#include "FgCommand.hpp"
#include "Fg3Sam.hpp"
#include "Fg3dMeshIo.hpp"
#include "FgSerial.hpp"
#include "algs.hpp"
#include "matrixCT.hpp"
#include "FgTransform.hpp"
#include "FgTime.hpp"
#include "bootPoints.hpp"
#include "FgParse.hpp"
#include "FgTestUtils.hpp"
#include "FgAnthropometry.hpp"
#include "Fg3PhotofitUtil.hpp"
 
using namespace std;
 
namespace Fg {
 
namespace {
 
void                maskFim(CLArgs const & args)
{
    Syntax
        syn(args,
            "<in>.fim <mask>.<img> <out>.fim\n"
            "    <img> = " + clOptionsStr(getImgExts()) + "\n"
            "    The mask image is made monochrome and thresholded in the middle");
    if (args.size() != 4)
        syn.errorNumArgs();
    syn.checkExtension(args[1],"fim");
    syn.checkExtension(args[2],getImgExts());
    syn.checkExtension(args[3],"fim");
    Img2F       in = loadFim(args[1]),out;
    ImgRgba8             mask = loadImage(args[2]);
    if (mask.dims() != in.dims())
        fgThrow("fim and mask dimensions do not match");
    out = in;
    for (uint yy=0; yy<mask.height(); ++yy) {
        for (uint xx=0; xx<mask.width(); ++xx) {
            uchar   mval = mask.xy(xx,yy).rec709();
            uint    idx = yy*out.width()+xx;
            if (mval > 127)
                out.m_data[idx] = in.m_data[idx];
            else
                out.m_data[idx] = Vec2F(-1.0f,-1.0f);
        }
    }
    Ofstream  ofs(args[3]);
    ofs.write("FIMFF001",8);
    ofs.write((char*)&out.m_dims[0],4);
    ofs.write((char*)&out.m_dims[1],4);
    char reserve[48];
    memset(&reserve[0],0,sizeof(reserve));
    ofs.write(reserve,48);
    ofs.write((char *)out.dataPtr(),out.numPixels()*sizeof(FutVect2FC));
}
 
void                cmdResample(CLArgs const & args)
{
    Syntax syn(args,
        "<transform>.fim <in>.<img> <out>.<img>\n"
        "<transform>.fim  - Created by Customizer\n"
        "<img>            - " + clOptionsStr(getImgExts())
        );
    Img2F   fim = loadFim(syn.next());
    ImgRgba8         img = loadImage(syn.next()),
                        ret = resampleMap(fim,img);
    saveImage(ret,syn.next());
}
 
void                egtToImgs(CLArgs const & args)
{
    Syntax syn(args,
        "<sam>.egt\n"
        "    Saves each mode as a separate image <sam>_egt_(S|A)_XX.png, in which the signed char values\n"
        "    are mapped to unsigned by lifting 0 to 128."
        );
    string          egtName = syn.next();
    Scm3SA          egt = loadEgt(egtName);
    Path          samPath(egtName);
    for (uint ss=0; ss<2; ++ss) {
        const vector<Scm3Mode> &  modes = (ss == 0) ? egt.symm : egt.asym;
        for (size_t ii=0; ii<modes.size(); ++ii) {
            const Scm3Mode &      mode = modes[ii];
            string  symm = (ss == 0) ? "S" : "A";
            fgout << fgnl << symm << " " << ii << " scale: " << mode.scale;
            ImgRgba8             img(mode.mode.dims());
            for (size_t jj=0; jj<img.numPixels(); ++jj) {
                Arr3SC          md = mode.mode.m_data[jj];
                Rgba8          col(0,0,0,255);
                for (uint cc=0; cc<3; ++cc)
                    col[cc] = scast<uchar>(scast<int>(md[cc])+128);
                img.m_data[jj] = col;
            }
            saveImage(img,samPath.dirBase()+"_egt_"+symm+"_"+toStr(ii)+".png");
        }
    }
}
 
void                xformSsm(CLArgs const & args)
{
    Syntax        syn(args,
        "<transform>.txt <in> <out>\n"
        "    <transform>.txt is created with the 'xform create' command\n"
        "    <in>.tri and <in>.egm must exist.\n"
        "    <out>.tri and <out>.egm will be written.\n"
        );
    SimilarityD         xform = dsrlzText<SimilarityD>(loadRawString(syn.next()));
    string              baseName = syn.next();
    Mesh                mesh = loadTri(baseName+".tri");
    Ssm3                ssm(mesh.verts,baseName+".egm");
    mesh.transform_(xform);
    ssm.transform(xform);
    baseName = syn.next();
    saveTri(baseName+".tri",mesh);
    ssm.saveModes(baseName+".egm");
}
 
void                cmdSsmZero(CLArgs const & args)
{
    Syntax              syn {args,
        R"(<marked>.<mesh> <ssmIn>.egm <ssmOut>.egm
    <marked>.<mesh> - must have the vertices whose SSM values are to be set to zero marked.
    <mesh>          - (tri,fgmesh)
    <ssmIn>.egm     - will be modified to this effect.
NOTES:
    * specified vertices will no longer be moved by FaceGen SSM statistics.
    * prefer the fixed seam vertices arguments in the 'ssm' command as that smoothly influences the
      surrounding space.)"
    };
    Mesh                mesh = loadMesh(syn.next());
    if (mesh.markedVerts.empty())
        syn.error("No marked vertices in mesh",syn.curr()+".tri");
    Ssm3                ssm {mesh.verts,syn.next()};
    if (ssm.empty())
        syn.error("No SSM modes found",syn.curr());
    for (uint ss=0; ss<2; ++ss) {
        Vec3Fss &           modes = (ss == 0) ? ssm.symmModes : ssm.asymModes;
        for (size_t mm=0; mm<modes.size(); ++mm) {
            Vec3Fs &            mode = modes[mm];
            if (mode.size() < mesh.verts.size())
                syn.error("EGM size too small for this TRI");
            for (size_t ii=0; ii<mesh.markedVerts.size(); ++ii)
                mode[mesh.markedVerts[ii].idx] = Vec3F(0);
        }
    }
    ssm.saveModes(syn.curr());
}
 
void                comvertLms(CLArgs const & args)
{
    Syntax              syn {args,R"((<base>.bpt.xml | <in>.lms.txt)
OUTPUT:
    <in>.lms.txt    - parsed (and converted if bpt.xml) landmarks in simple text format (aka YOLO format)
NOTES:
    Only applies to FaceGen V3 landmarks; 11 for frontal and 9 for profile.)"
    };
    Path                path {syn.next()};
    syn.noMoreArgsExpected();
    Vec2Fs              poss;
    if (path.ext == "xml") {
        Strings             oldStrs = splitLines(loadRawString(path.str()));
        for (String const & os : oldStrs) {
            Strings             toks = tokenize(os);
            if (toks.size() == 8) {               // < column > ### < / column >
                if (toks[1] == "column")
                    poss.push_back(Vec2F{fromStr<float>(toks[3]).value(),0});
                else if (toks[1] == "row")
                    poss.back()[1] = fromStr<float>(toks[3]).value();
            }
        }
    }
    else if (path.ext == "txt")
        poss = mapMember(loadLandmarks(path.str()),&NameVec2F::vec);      // ditch names and re-parse
    else
        syn.error("Unrecognized LMS file type");
    ViewLmPoss          fls = parseLmsV3(poss);
    NameVec2Fs          nvs = toNameVecs(fls.lms);
    path.base = cSubstr8(path.base,0,path.base.size()-4);
    saveLandmarks(nvs,path.dirBase()+".lms.txt");
    fgout << fgnl << fls.lms.size() << " points parsed for " << fls.view << " view";
}
 
void                cmdSsmSplice(CLArgs const & args)
{
    Syntax              syn {args,
        R"(<src1>.egm <src2>.egm <inds>.txt <dst>.egm
    <src1>.egm      - take deformations from this EGM (skin deformation)
    <src2>.egm      - replace deformations from this EGM (eye motions)
    <inds>.txt      - replace only the deformations for these indices
    <dst>.egm       - write the combined deformations here
NOTES:
    <src1> and <src2> must have the same vertex count)"
    };
    Vec3Fss             src1S,src1A,src2S,src2A;
    uint32              V = loadEgm_(syn.next(),src1S,src1A),
                        V2 = loadEgm_(syn.next(),src2S,src2A);
    if (V != V2)
        syn.error("<src1> and <src2> have different vertex counts",toStr(V)+"!="+toStr(V2));
    FGASSERT(src1S.size() == src2S.size());
    FGASSERT(src1A.size() == src2A.size());
    Vec3Fss             dstS = src1S,
                        dstA = src1A;
    Strings             strs = splitWhitespace(loadRawString(syn.next()));
    for (String const & str : strs) {
        Opt<uint>           ou = fromStr<uint>(str);
        if (!ou.has_value())
            syn.error("Invalid value in <inds>",str);
        uint                idx = ou.value();
        for (size_t ss=0; ss<src1S.size(); ++ss)
            src1S[ss][idx] = src2S[ss][idx];
        for (size_t aa=0; aa<src1A.size(); ++aa)
            src1A[aa][idx] = src2A[aa][idx];
    }
    saveEgm(syn.next(),dstS,dstA);
}
 
}
 
Cmd                 getCmd3EndianToggle();
 
void                cmd3Util(CLArgs const & args)
{
    Cmds            cmds {
        {comvertLms,"lms","Convert old bpt.xml image landmark files to simpler .lms.txt"},
        {egtToImgs,"egtToImgs","Convert an EGT into a series of images for examination"},
        {getCmd3EndianToggle()},
        {cmdGetInternal,"internal","Save a copy of the FaceGen internal base face in the current directory"},
        {maskFim,"maskFim","Mask an image transform map (.fim) to set some areas to invalid"},
        {cmdResample,"resample","Resample an image based on an image transform map in the .FIM format"},
        {cmdSsmSplice,"ssmSplice","Splice together vertex deformations from different EGMs (for eye motions)"},
        {cmdSsmZero,"ssmZero","Set the SSM values of the marked vertices to zero"},
        {xformSsm,"xformSsm","Apply a similarity transform to a SSM (.TRI and .EGM)"},
    };
    doMenu(args,cmds);
}
 
}