FgApply.cpp

//
// Copyright (c) Singular Inversions Inc. 2014
//
// Authors: Andrew Beatty
// Created: Jan 2, 2014
//
 
#include "stdafx.h"
 
#include "FgApply.hpp"
 
using namespace std;
 
namespace Fg {
 
Arr<ScaleTrans3F,2> cEyesTransform(FaceLmPos3Fs const & lmBases,Vec3Fs const & allTargs)
{
    FGASSERT(lmBases.size() == allTargs.size());      // must be 1-1
    auto                    cXf = [&](FaceLm upperCentre,FaceLm lowerCentre,FaceLm endocanthion,FaceLm exocanthion)
    {
        Arr<size_t,4>           inds {
            findFirstIdx(lmBases,upperCentre,true),
            findFirstIdx(lmBases,lowerCentre,true),
            findFirstIdx(lmBases,endocanthion,true),
            findFirstIdx(lmBases,exocanthion,true),
        };
        Arr<Vec3F,4>            bases = mapCall(inds,[&](size_t idx){return lmBases[idx].pos; });
        Arr<Vec3F,4>            targs = mapIndex(inds,allTargs);
        // this algo differs from G8.1 and earlier algo (baked into EGM) since eyes are deeper in G9:
        Vec3F                   centreB = cMean(bases),
                                centreT = cMean(targs),
                                delta = centreT - centreB,
                                canthCentreB = (bases[2] + bases[3]) * 0.5,
                                canthCentreT = (targs[2] + targs[3]) * 0.5,
                                canthDelta = canthCentreT - canthCentreB;
        // X values of lids are not well defined so don't use:
        delta[0] = canthDelta[0];
        float                   sizeB = scast<float>(cLenD(bases[2]-bases[3])),
                                sizeT = scast<float>(cLenD(targs[2]-targs[3])),
                                scale = sizeT / sizeB;
        return ScaleTrans3F{canthCentreB+delta} * ScaleTrans3F{scale} * ScaleTrans3F{-canthCentreB};
    };
    return {
            cXf(FaceLm::lidUpperCentreL,FaceLm::lidLowerCentreL,FaceLm::endocanthionL,FaceLm::exocanthionL),
            cXf(FaceLm::lidUpperCentreR,FaceLm::lidLowerCentreR,FaceLm::endocanthionR,FaceLm::exocanthionR),
    };
}
 
Arr3D               sampleColor(ImgRgba8 const & img,ImgUC const & region)
{
    FGASSERT(areColinear(img.dims(),region.dims()));
    float               scaleToColor = scast<float>(img.dims()[0]) / scast<float>(region.dims()[0]);
    size_t              taps {0};
    Arr3UL              acc {0};
    for (Iter2UI it{region.dims()}; it.valid(); it.next()) {
        if (region[it()] == 255) {      // iris sample region
            Vec2F               pacs = (Vec2F{it()} + Vec2F{0.5,0.5}) * scaleToColor;
            Rgba8               clr = img[Vec2UI{pacs}];
            for (uint cc=0; cc<3; ++cc)
                acc[cc] += clr[cc];
            ++taps;
        }
    }
    FGASSERT(taps > 0);
    return mapCast<double>(acc) / scast<double>(taps);          // still [0,255]
};
 
void                shiftColor_(Arr3D delta,ImgUC const & region,ImgRgba8 & img)
{
    float               scaleToRegion = scast<float>(region.width()) / scast<float>(img.width());
    for (Iter2UI it{img.dims()}; it.valid(); it.next()) {
        Vec2F               pacs = (Vec2F{it()} + Vec2F{0.5}) * scaleToRegion;
        double              delFac = scast<double>(region[Vec2UI{pacs}]) / 255.0;
        Rgba8 &             pix = img[it()];
        for (uint cc=0; cc<3; ++cc) {
            double              val = delta[cc] * delFac + pix[cc];
            pix[cc] = scast<uchar>(clamp(val,0.0,255.0));
        }
    }
}
 
}