AutoExposure.cpp

#include "AutoExposure.h"

#include "Frame.h"
#include "Sensor.h"
#include "Shot.h"

namespace FCam {
    void autoExpose(Shot *s, Frame::Ptr f,
            float maxGain,
            int maxExposure,
            float smoothness) {
    

    if (!f) return; 
    if (!s) return;

    // autoexpose based on the histogram
    int b = f->histogram.buckets;

    int cdf[256]; // a CDF for histograms of up to 256 buckets

    if (!f->histogram.valid) return;
    if (b > 256 || b < 64) return;

    cdf[0] = f->histogram(0);
    for (int i = 0; i < b; i++) {
        cdf[i] = cdf[i-1] + f->histogram(i);
    }

    int brightPixels = cdf[b-1] - cdf[b-11]; // top 10 buckets
    int targetBrightPixels = (f->histogram.region[0].width*
                  f->histogram.region[0].height)/100;
        
    // how much should I change brightness by 
    float adjustment = 1.0f;

    if (brightPixels > targetBrightPixels) {
        // do something based on what fraction of the frame is too bright
        adjustment = 1.0f - ((float)(brightPixels - targetBrightPixels))/(f->image.size.width*f->image.size.height);
    } else {
        // walk down in brightness until enough pixels are overexposed
        int l = b-11;
        while (brightPixels < targetBrightPixels && l > 0) {
        brightPixels += cdf[l];
        brightPixels -= cdf[l-1];
        l--;
        }
        
        // that level is supposed to be at b-11;
        adjustment = float(b-11+1)/(l+1);
        
    }

    if (adjustment > 4.0) adjustment = 4.0;
    if (adjustment < 1/16.0f) adjustment = 1/16.0f;

    float brightness = f->gain * f->exposure;
    float desiredBrightness = brightness * adjustment;  
    int exposure;
    float gain;

    // whats the largest we can raise exposure without negatively
    // impacting frame-rate
    int exposureKnee = s->frameTime - 400;

    if (desiredBrightness > exposureKnee) {
        exposure = exposureKnee;
        gain = desiredBrightness / exposureKnee;
    } else {
        gain = 1.0f;
        exposure = desiredBrightness;
    }

    // Clamp the gain at max, and try to make up for it with exposure
    if (gain > maxGain) {
        exposure = desiredBrightness/maxGain;
        gain = maxGain;
    } 

    // Finally, clamp the exposure at max
    if (exposure > maxExposure) {
        exposure = maxExposure;
    }

    s->exposure  = s->exposure*smoothness + exposure*(1-smoothness);
    s->gain      = s->gain*smoothness + gain*(1-smoothness);
    }
}

---