Fg3CmdRandom.cpp

//
// Copyright (c) Singular Inversions Inc. 2013
//
// Authors:     Andrew Beatty
// Created:     Oct 15, 2013
//
 
#include "stdafx.h"
 
#include "FgCommand.hpp"
#include "FgFileSystem.hpp"
#include "Fg3dMeshIo.hpp"
#include "FgCamera.hpp"
#include "FgRender.hpp"
#include "FgTime.hpp"
#include "Fg3Sam.hpp"
#include "Fg3Controls.hpp"
#include "FgImageIo.hpp"
 
using namespace std;
 
namespace Fg {
 
namespace {
 
struct      Render
{
    // 0 - light direction fixed behind camera.
    // 0.5 - light randomly from camera hemisphere.
    // 1 - light randomly from any direction:
    float               lightDirectionRange {0.3f};
    RgbaF               backgroundColor {0,0,0,0};      // [0,255] per channel
    Vec2UI              imagePixelSize {512,512};
    uint                antiAliasBitDepth {3};
    float               cameraFovDegrees {17};          // FOV of larger image dimension.
    FG_SER5(lightDirectionRange,backgroundColor,imagePixelSize,antiAliasBitDepth,cameraFovDegrees)
};
 
struct      Pose
{
    Rigid3D             toHcs;                    // defaults to identity
    double              scale {1};
    Vec2D               rollRangeDegrees {-5,5};
    Vec2D               tiltRangeDegrees {-10,10};
    Vec2D               panRangeDegrees {-45,45};
    FG_SER5(toHcs,scale,rollRangeDegrees,tiltRangeDegrees,panRangeDegrees)
};
 
struct      LockVal
{
    bool                fixed {false};
    float               val {0};                // Will be set to val if fixed, ignored otherwise
    FG_SER2(fixed,val)
};
 
struct      LockVal2
{
    bool                fixed {false};
    float               shape {0};              // Will be set to val if fixed, ignored otherwise
    float               color {0};              // "
    FG_SER3(fixed,shape,color)
};
 
struct      Attributes
{
    int                     genderDistro {0};   // -1 - male, 0 - either, 1 - female, 2 - fixed
    float                   genderFixval {0};   // Ignored if above value is not 2
    LockVal                 age;
    LockVal2                caricature;
    LockVal                 asymmetry;
    FG_SER5(genderDistro,genderFixval,age,caricature,asymmetry)
};
 
struct      Options
{
    Strings                 sams;
    Stringss                optsSams;       // Empty string is null choice.
    Stringss                optsMorphs;     // "
    bool                    useDetailTextures {true};
    Pose                    pose;
    Render                  rend;
    string                  outputFormat {".jpg"};
    Attributes              attributes;
    FG_SER8(sams,optsSams,optsMorphs,useDetailTextures,pose,rend,outputFormat,attributes)
};
 
void                setup(CLArgs const & args)
{
    Syntax          syn {args,
        R"(<config>.txt (<sam>)+ [-s (<sam>)+]* [-m (<morph>)+]*
     <sam>         - A SAM name (file path without extension)
     -s            - A list of SAMs from which one will be chosen at random
     -m            - A list of morphs from which one will be chosen at random
                   - Use "" for the null choice in either list above.
OUTPUT:
    <config>.txt    A configuration file that can be modified and used to do a random run
NOTES:
    Fields in the configuration file can be modified as long as the XML structure is not changed:
    <sams>          add or remove more SAM base names in the <item> elements
    <optsSams>      add / remove SAM base names one of which will be chosen at random (empty means none)
    <optsMorphs>    add / remove morph names, one of which will be chosen at random (empty means none)
    <useDetailTextures> 0 - no, 1 - yes
    <pose>
        <toHcs> all meshes will be rigidly transformed to put them in the head coordinate
            system (HCS) which is X - left, Y - up, Z - toward camera
        <scale>     scale relative to the scale that would result in a good portrait fill of the image
        <rollRangeDegrees> limits of roll angle to be chosen randomly (uniform)
        <tiltRangeDegrees> limits of tilt angle to be chosen randomly (uniform)
        <panRangeDegrees> limits of pan angle to be chosen randomly (unform)
    <rend>
        <lightDirectionRange> [0,1] angle range of light source (at infinity) as a ratio of full circle
        <backgroundColor> [0,255] per channel RGBA
        <imagePixelSize> desired pixel width, height
        <antiAliasBitDepth> 3 is high quality (equivalent to 8x FSAA) without running too slowly
        <cameraFovDegrees> field of view or the larger image dimension in degrees. Default is 17
            (ie. moderate zoom lens). Use a larger FOV to simulate a mobile device camera.
    <outputFormat> )" + clOptionsStr(getImgExts()) + R"(
    <attributes>
        <genderDistro> 0 - choose at random, 1 - female, -1 - male, 2 - use the fixed value in <genderFixed>
        <genderFixval> exact gender projection (genders normally fall into a range of values)
        <age>
            <fixed> 0 - varies randomly, 1 - fixed to <val>
            <val> exact age projection
        <caricature>
            <fixed> 0 - varies randomly, 1 - fixed to <shape> and <color>
            <shape> exact shape caricature projection
            <color> exact color caricature projection
        <asymmetry>
            <fixed> 0 - varies randomly, 1 - fixed to <val>
            <val> exact asymmetry
)"
    };
    if (args.size() < 3)
        syn.errorNumArgs();
    string          configFile = syn.next();
    Options         opt;
    while (syn.more()) {
        if (syn.peekNext()[0] == '-')
            break;
        opt.sams.push_back(syn.next());
    }
    while (syn.more()) {
        string      optstr = syn.next();
        if (optstr == "-s") {
            Strings  optSams;
            while (syn.more() && (syn.peekNext()[0] != '-'))
                optSams.push_back(syn.next());
            opt.optsSams.push_back(optSams);
        }
        else if (optstr == "-m") {
            Strings  optMorphs;
            while (syn.more() && (syn.peekNext()[0] != '-'))
                optMorphs.push_back(syn.next());
            opt.optsMorphs.push_back(optMorphs);
        }
        else
            syn.error("Unrecognized option",syn.next());
    }
    saveRaw(srlzText(opt),configFile);
}
 
struct      Model
{
    Sam3            sam;
    ImgRgba8s       colors;     // If sam has no SCM, pick one of these at random    
 
    Model() {}
    explicit Model(string const & name) : sam(name)
    {
        if (!(name.empty()) && sam.mesh.verts.empty())
            fgout << fgnl << "WARNING: SAM not found: " << name;
    }
 
    Mesh                construct(Face3 const & face)
    {
        sam.applyFace(face);
        Mesh            mesh = sam.mesh;
        if (!mesh.surfaces.empty()) {
            Surf &          surf = mesh.surfaces[0];
            if (!colors.empty()) {  // Surfaces for some reason constructed with size 0 abedo map so ignore that
                uint            sel = randUniformUint(uint(colors.size()));
                surf.material.albedoMap = std::make_shared<ImgRgba8>(colors[sel]);
            }
        }
        return mesh;
    }
};
typedef vector<Model>   Models;
typedef vector<Models>  Modelss;
 
double              interpolate(Vec2D bounds,double val) {return bounds[0] * (1.0-val) + bounds[1] * val; }
 
void                rrun(CLArgs const & args)
{
    Syntax          syn {args,R"(<config>.txt <label> <number>
    <config>.txt  - Configuration file for the random run (create using 'fg3 random setup')
    <label>       - Base label for the output images.
    <number>      - How many random images to generate.
OUTPUT:
    For each sample, the following files with base name '<label>####' are generated:
        .jpg    rendered image
        .fg     face coordinate and detail texture if selected
        .txt    face coordinate values in TXT format.)"
    };
    Options         opt = dsrlzText<Options>(loadRawString(syn.next()));
    if (!opt.pose.toHcs.rot.normalize())
        fgThrow("toHcs::rot: quaternion cannot be zero magnitude");
    if (opt.pose.scale <= 0)
        fgThrow("Scale must be greater than 0");
    String          label = syn.next();
    size_t          num = syn.nextAs<size_t>();
    if (num < 1)
        syn.error("No images generated");
 
    randSeedTime();
 
    Models          sams;
    for (size_t ii=0; ii<opt.sams.size(); ++ii)
        sams.push_back(Model(opt.sams[ii]));
    Modelss         optsSams;
    for (Strings const & optSamsBn : opt.optsSams) {
        Models          optSams;
        for (string const & optName : optSamsBn) {
            if (optName.empty())
                optSams.push_back(Model());
            else {
                Model       model(optName);
                if (model.sam.scms.empty()) {
                    Path            path(optName);
                    String8s        clrFiles = globFiles(String8(optName)+"_*.*");
                    for (String8 const & cf : clrFiles)
                        model.colors.push_back(loadImage(path.dir()+cf));
                }
                optSams.push_back(model);
            }
        }
        optsSams.push_back(optSams);
    }
    Sam3Controls    ctls(dataDir() + "main/si.ctl");
 
    Affine3F            xf {opt.pose.toHcs.asAffine()};
    Mat32F              bounds = cBounds(mapMul(xf,sams[0].sam.ssm.meanVerts));
    for (size_t ii=1; ii<sams.size(); ++ii)
        bounds = cBoundsUnion(bounds,cBounds(mapMul(xf,sams[ii].sam.ssm.meanVerts)));
    CameraParams        cps {Mat32D{bounds}};
    cps.logRelScale = std::log(opt.pose.scale);
    cps.fovMaxDeg = opt.rend.cameraFovDegrees;
    Camera              baseCam = cps.camera(opt.rend.imagePixelSize);
 
    for (size_t ii=0; ii<num; ++ii) {
        Face3           face;
        if (opt.attributes.age.fixed) {
            ctls.setAge_(face.coord,FANTYPE_GEO,opt.attributes.age.val);
            ctls.setAge_(face.coord,FANTYPE_TEX,opt.attributes.age.val);
        }
        FanGender       gender = FANGENDER_SIZE;
        if (opt.attributes.genderDistro != 0) {
            if (opt.attributes.genderDistro == -1)
                gender = FANGENDER_MALE;
            else if (opt.attributes.genderDistro == 1)
                gender = FANGENDER_FEMALE;
            else if (opt.attributes.genderDistro == 2) {
                if (opt.attributes.genderFixval > 0.0f)
                    gender = FANGENDER_FEMALE;
                else if (opt.attributes.genderDistro < 0.0f)
                    gender = FANGENDER_MALE;
            }
            else
                syn.error("Gender value must be 0 (random), -1 (male), +1 (female), or 2 (fixed)");
        }
        if (opt.attributes.caricature.fixed) {
            face.coord.ts(0,0)[0] = 1.0f;   // Must be non-zero to set caricature
            face.coord.ts(1,0)[0] = 1.0f;   // "
            ctls.setCaricature_(face.coord,FANRACE_ALL,FANTYPE_GEO,opt.attributes.caricature.shape);
            ctls.setCaricature_(face.coord,FANRACE_ALL,FANTYPE_TEX,opt.attributes.caricature.color);
        }
        if (opt.attributes.asymmetry.fixed) {
            face.coord.ts(0,1)[0] = 1.0f;
            ctls.setAsymmetry_(face.coord,opt.attributes.asymmetry.val);
        }
        ctls.setRandom_(face.coord,FANRACE_ALL,gender,opt.attributes.age.fixed,opt.attributes.caricature.fixed,opt.attributes.asymmetry.fixed);
        if (opt.attributes.genderDistro == 2) {
            ctls.setGender_(face.coord,FANTYPE_GEO,opt.attributes.genderFixval);
            ctls.setGender_(face.coord,FANTYPE_TEX,opt.attributes.genderFixval);
        }
        if (opt.useDetailTextures) {
            string          genStr = (ctls.getGender(face.coord,FANTYPE_GEO) > 0 ? "Male " : "Female ");
            float           age = ctls.getAge(face.coord,FANTYPE_GEO);
            string          ageStr;
            if (age < 40)
                ageStr = "Young ";
            else if (age < 60)
                ageStr = "Middle ";
            else
                ageStr = "Older ";
            String8         sw = dataDir()+"main/detail/"+genStr+ageStr;
            Path            swp(sw);
            DirContents dc = globNodeStartsWith(swp);
            FGASSERT(!dc.filenames.empty());
            String8         detFile = swp.dir() + dc.filenames[randUniformUint(uint(dc.filenames.size()))];
            face.detail = loadRaw(detFile);
        }
        Meshes          meshes;
        for (Model & sam : sams)
            meshes.push_back(sam.construct(face));
        for (Models & optSams : optsSams) {
            size_t          idx = randUniformUint(uint(optSams.size()));
            Model &         sam = optSams[idx];
            if (!sam.sam.mesh.verts.empty())
                meshes.push_back(sam.construct(face));
        }
        Strings              morphs;
        for (size_t jj=0; jj<opt.optsMorphs.size(); ++jj) {
            string          morph = opt.optsMorphs[jj][randUniformUint(uint(opt.optsMorphs[jj].size()))];
            if (!morph.empty())
                morphs.push_back(morph);
        }
        for (size_t jj=0; jj<meshes.size(); ++jj) {
            Mesh &      mesh = meshes[jj];
            Floats   morphCoord(mesh.numMorphs(),0);
            for (size_t kk=0; kk<morphs.size(); ++kk) {
                Valid<size_t> morphIdx = mesh.findMorph(morphs[kk]);
                if (morphIdx.valid())
                    morphCoord[morphIdx.val()] = 1.0f;
            }
            mesh.morph(morphCoord,mesh.verts);
            mesh.transform_(SimilarityD{opt.pose.toHcs});
        }
        QuaternionD         pose =
                cRotateY(degToRad(interpolate(opt.pose.panRangeDegrees,randUniform()))) *
                cRotateX(degToRad(interpolate(opt.pose.tiltRangeDegrees,randUniform()))) *
                cRotateZ(degToRad(interpolate(opt.pose.rollRangeDegrees,randUniform())));
        Camera              cam = baseCam;
        cam.modelview.rot = baseCam.modelview.rot * pose;
        RenderOptions       ro;
        float               lr = opt.rend.lightDirectionRange;
        Vec3F               ld = ro.lighting.lights[0].direction;
        ld = ld * (1-lr) + Vec3F::randNormal(lr);
        ro.lighting.lights[0].direction = normalize(ld);
        ro.backgroundColor = opt.rend.backgroundColor;
        ro.antiAliasBitDepth = opt.rend.antiAliasBitDepth;
        ImgRgba8             image = renderSoft(opt.rend.imagePixelSize,meshes,cam.modelview,cam.itcsToIucs,ro);
        string              base = label + toStrDigits(ii,4);
        saveImage(image,base+opt.outputFormat);
        face.save(base+".fg");
        saveRaw(srlzText(face.coord),base+".txt");
    }
}
 
}
 
void                cmd3Random(CLArgs const & args)
{
    Cmds            cmds {
        {setup,"setup","Setup an XML file describing a random image batch run"},
        {rrun,"run","Run random image batch creation from an XML description"},
    };
    doMenu(args,cmds);
}
 
}