Fg3Scm.hpp

//
// Copyright (c) Singular Inversions Inc. 2012
//
// Authors:     Andrew Beatty
// Created:     Feb 14, 2012
//
 
#ifndef FG3SCM_HPP
#define FG3SCM_HPP
 
#include "Fg3Face.hpp"
#include "FgImage.hpp"
#include "Fg3dMeshIo.hpp"
#include "FgMain.hpp"
#include "FgVolume.hpp"
 
namespace Fg {
 
struct      Scm3Mode
{
        float           scale;
        Img3SC          mode;       // RGB deltas for [0,255] channel scaled by 1/scale above
};
typedef Svec<Scm3Mode>  Scm3Modes;
 
struct      Scm3SA
{
    Scm3Modes           symm;
    Scm3Modes           asym;
};
 
Scm3SA              loadEgt(String8 const & egtFile);
Img2F               loadFim(String8 const & fimFile);
ImgV3F              scmMac(
    Scm3Modes const &   modes,      
    Floats const &      coeffs);    
ImgRgba8            scmAdd(
    ImgRgba8 const &    scmMean,            // SCM mean image RGBA [0,255]. Can be empty.
    ImgV3F const &      delta,              // SCM delta computed with 'scmMac'. Can be smaller than 'mean'. Or empty.
    float               outInvGamma=2.2,    // Inverse gamma of return image
    bool                multithread=true);  // select false if called within a multithreaded context
Arr3D               calcColorFac(
    ImgRgba8 const &    genericMap,
    ImgRgba8 const &    facegenMap,
    ImgUC const &       sampleRegion);     // [0,255]
ImgRgba8            applyColorFac(ImgRgba8 const & genericMap,Arr3D colorFac);
Arr3D               calcColorShift(
    ImgRgba8 const &    genericFaceMap,
    ImgRgba8 const &    facegenFaceMap,
    ImgUC const &       transitionMap);
ImgRgba8            applyColorShift(ImgRgba8 const & customBodyMap,Arr3D shift);
ImgRgba8            applyOverlay(ImgRgba8 const & base,ImgRgba8 const & overlay);
 
struct      Scm3
{
    ImgRgba8            mean;
    Scm3Modes           modes;
    Img2F               detailXfm;
    float               gamma = gammaDefault();
    ImgRgba8            overlay;
    ImgUC               fadeMap;
 
    static inline float gammaDefault() {return 2.2f; }
 
    Scm3() {}
    Scm3(String8 const & dirBase,String8 const & overlayColor="");
    Scm3(
        String8 const &     imgFile,
        String8 const &     egtFile,    
        String8 const &     fimFile);   
    Scm3(
        ImgRgba8 const &    meanClr,
        String8 const &     egtFile,    
        String8 const &     fimFile);   
 
    bool                empty() const {return (mean.empty() && overlay.empty()); }
 
    ImgRgba8            calcScmColorMap(
        Sam3Coord const &   faceCoord,
        bool                multithread=true)
        const
    {
        if (modes.empty())
             return mean;
        ImgV3F           accDelta = scmMac(modes,faceCoord.ts(1,0));
        return scmAdd(mean,accDelta,gamma,multithread);
    }
 
    ImgRgba8            applyFace(
        Face3 const &       face,
        float               detailModulation=1.0f,
        bool                multithread=true)
        const
    {
        ImgRgba8      td = transformDetail(face.detail,multithread);
        return applyFaceCoord(face.coord.ts(1,0),td,detailModulation,multithread);
    }
 
    ImgRgba8            transformDetail(
        Bytes const &  detailJpegBlob,         // JPEG encoded modulation map in FaceGen internal layout
        bool            multithread=true) const; // select false if this function is from a multithreaded context
 
    ImgRgba8            applyFaceCoord(
        Floats const &      ColorCoordS,
        ImgRgba8 const &     transformedDetail,
        float               detailModulation=1.0f,
        bool                multithread=true)       // select false if calling within multithreaded context
        const;
};
typedef Svec<Scm3>  Scm3s;
 
// Return the skin sample region (skin areas not including any areas where beard or eyebrow hair can grow, or the nose):
ImgUC               getSkinSampleRegion(Img2F const & detailXfm);
 
inline ImgRgba8     customizeBase(
    ImgRgba8 const &        facegenBase,        // the skin color map created by FaceGen 'scm' command
    ImgRgba8 const &        customBase,         // your replacement
    ImgUC const &           transition,         // transition from FaceGen (black) to your (white) map
    Arr3D                   colorShift)         // computed previously using 'calcColorShift'
{
    return imgBlend(facegenBase,applyColorShift(customBase,colorShift),transition);
}
 
// optional add zero modes to the end:
Volume<Arr3F>       loadEgtScm4(String8 const & egtFile,size_t padZero=0);
 
// Required: modes.dims() == [coeffs.size(),acc.width(),acc.height()]
void                multAcc_(Volume<Arr3F> const & modes,Floats const & coeffs,Img3F & acc);
// Required: modes.dims()[0] == coeffs.size():
Img3F               multAcc(Volume<Arr3F> const & modes,Floats const & coeffs);
 
struct      ScbLpp
{
    Img3F                   base;           // RGB [0,1]
    Volume<Arr3F>           modes;          // Z: image-Y, Y: image-X, X: mode deltas scaled for [0,1]
 
    ScbLpp(String8 const & dirBase);
 
    size_t                  numModes() const {return modes.dims()[0]; }
    Vec2UI                  dims() const {return base.dims(); }
    inline Img3F            apply(Floats const & coord) const {return base + multAcc(modes,coord); }
    ImgRgba8                apply(Floats const & coord,float gamma) const;
};
 
 
void                cmdScm3Base(CLArgs const &);    // SCM integration custom base command
 
}
 
#endif