FanControls.hpp

//
// Copyright (c) Singular Inversions Inc. 2001.
//
// Authors: Andrew Beatty
// Date:    June 25, 2001
//
 
#ifndef FAN_CONTROLS_HPP
#define FAN_CONTROLS_HPP
 
#include "FgSerial.hpp"
#include "Fg3Face.hpp"
#include "matrixCT.hpp"
#include "binaryFile.hpp"
 
namespace Fg {
 
 typedef enum            // Enumerate racial groups
{
    FANRACE_ALL = 0,
    FANRACE_AFRO,
    FANRACE_EASIA,
    FANRACE_SASIA,
    FANRACE_EURO,
 
    FANRACE_SIZE
 
}    FanRaceE;
 
String8s
fg3RaceLabels();
 
typedef enum            // Enumerate attributes
{
    FANATT_AGE = 0,
    FANATT_GENDER,
 
    FANATT_SIZE
 
}    FanAttribE;
 
typedef enum            // Enumerate genders
{
    FANGENDER_MALE = 0,
    FANGENDER_FEMALE,
 
    FANGENDER_SIZE      // Also used to indicate any gender.
 
}   FanGender;
 
struct    FanLinCtlS                        // Linear Control Structure
{
    FanLinCtlS() : useWideChar(false) {}
 
    MatF                ctl;            // Covariant row vector represents 1 std.
                                        // linear control.
    std::string         label;
 
    // Added the following 2 to handle cases where unicode are used.
    std::wstring        wlabel;
    bool                useWideChar;
};
 
struct    Sam3LinCtrls                    // All linear control groups.
{
    Svec<FanLinCtlS>    grp[FANTYPE_SIZE][FANSYMM_SIZE];
 
    bool        readFromFile(FutBinaryFileC &file,
                    uint dim[FANTYPE_SIZE][FANSYMM_SIZE],
                    bool useWideChar=false);
    bool        writeToFile(FutBinaryFileC &file,
                    const uint dim[FANTYPE_SIZE][FANSYMM_SIZE],
                    bool useWideChar=false) const;
    void        setBasis(FanTypeE,FanSymmE,uint);
};
 
struct    FanRaceDistS
{
    MatF         mean[FANTYPE_SIZE];    // Column vector over geometry
 
        // Columns are the eigenbasis, and dimensions are concatenation 
        // of geometry & texture (symmetric only). Transforms from Mahalanobis
        // coords for this race into global face space coords.
    MatF         eigBasis;
 
        // Inverse of the PARTITIONED eigenbasis matrices - transforms from
        // global face space partioned coords to partitioned Mahalanobis 
        // coords for this race.
    MatF            invEigBasis[FANTYPE_SIZE];
};
 
struct    FanOffLinCtlS
{
    MatF                ctl[FANTYPE_SIZE];    // Row vector represents 1 std. linear control.
    float               scale;
    float               off;
};
 
struct    FanPrtOffLinCtlS              // Partitioned OLC - separate
{                                       // controls for Geo & Tex subspaces
    MatF                ctl;            // Row vector represents 1 std. linear control.
    float               scale;
    float               off;
};
 
struct  FanGenderDist
{
    MatF     mean[FANTYPE_SIZE];     // Column vector.
    MatF     eigBasis;               // Distribution eigenbasis over combined space.
};
 
struct    Sam3NLCtrls
{
    bool                initialized;    // Have the controls been initialized ?
        // Race-attribute controls
    FanRaceDistS        distrib[FANRACE_SIZE];
    FanPrtOffLinCtlS    attr[FANRACE_SIZE][FANATT_SIZE][FANTYPE_SIZE];
        // Race-race controls.
    FanOffLinCtlS        raceCtrls[FANRACE_SIZE][FANRACE_SIZE];
        // The orthogonal basis vectors of the caricature null space. (row
        // vector, spans the attribute subspace).
    MatF                basis[FANRACE_SIZE][FANTYPE_SIZE][FANATT_SIZE];
        // The inverse attribute covariance matrix:
    Mat22F                invAttCov[FANRACE_SIZE][FANTYPE_SIZE];
 
        // The male and female separated distributions for all races:
    FanGenderDist       genderDistrib[FANGENDER_SIZE];
 
    Sam3NLCtrls() : initialized(false) {};
 
    bool        readFromFile(FutBinaryFileC &file,uint dim[FANTYPE_SIZE][FANSYMM_SIZE]);
    float       getAttribute(FanRaceE,FanAttribE,FanTypeE,Sam3Coord const &) const;
    void        setAttributes(FanRaceE,FanTypeE,const float val[FANATT_SIZE],Sam3Coord &) const;
    float       getCaricature(FanRaceE,FanTypeE,FanSymmE,Sam3Coord const &) const;
    void        setCaricature_(FanRaceE,FanTypeE,FanSymmE,float,Sam3Coord &) const;
    float       getRace(FanRaceE,FanRaceE,Sam3Coord const &,FanTypeE type=FANTYPE_SIZE) const;
    float       getRaceCS(FanRaceE,FanRaceE,Floats const &) const;
    void        setRace_(FanRaceE,FanRaceE,float,Sam3Coord &,FanTypeE type=FANTYPE_SIZE) const;
 
    Sam3Coord
    random(
        FanRaceE            race,           
        FanGender           gender,         
        float               GSstdev=1.0f,
        float               GAstdev=1.0f,
        float               TSstdev=1.0f) const;
 
    Sam3Coord
    randomHispanic(
        FanGender           gender,         
        float               GSstdev=1.0f,
        float               GAstdev=1.0f,
        float               TSstdev=1.0f) const;
 
    Floats
    geneticRandom(
        float               randomness,         
        Floats const &      baseCoord) const;   
 
    Sam3Coord
    geneticRandom(
        float               randomness,         
        Sam3Coord const &   baseCoord) const;
 
    void    reflect(FanRaceE,Sam3Coord &) const;
 
    void
    geneticTween(FanTypeE,FanSymmE,float,Sam3Coord const &,Sam3Coord const &,Sam3Coord &);
 
    Sam3Coord
    genderRandom(
        FanGender           gend,           
        float               GSstdev=1.0f,
        float               GAstdev=1.0f,
        float               TSstdev=1.0f) const;
 
private:
    Sam3Coord
    randomUnimodal(
        FanRaceE            race,
        float               GSstdev,
        float               GAstdev,
        float               TSstdev) const;
};
 
}
 
#endif