tests/testF2.cpp

// A simple test program to verify timing and functionality of the F2 under FCAM

#include "FCam/F2.h"
#include <cmath>
#include <algorithm>
#include <fstream>
#include <stdio.h>

typedef std::vector<FCam::Shot> Burst;

void roiTimingTest() {
    using namespace FCam::F2;
    using namespace std;
    char buf[256];
    FILE *fp;

    printf("roiTimingTest: Tabulating frame time changes with ROI\n"
       "-------------------------------------------\n");

    fp = fopen("roiTiming.csv", "w");
    if (fp == NULL) {
    printf("Unable to open stats file roiTiming.csv, exiting\n");
    return;
    }

    int e[] = {1000,5000,10000,20000,40000,80000};
    vector<int> exposures(e, e + sizeof(e)/sizeof(int));

    int ft[] = {15000,20000,40000,80000};
    vector<int> frameTimes(ft, ft + sizeof(ft)/sizeof(int));

//     RowSkip::e rs[] = { RowSkip::none, RowSkip::x2, RowSkip::x3, RowSkip::x4,
//          RowSkip::x5, RowSkip::x6, RowSkip::x7, RowSkip::x8 };
    RowSkip::e rs[] = { RowSkip::none, RowSkip::x2, RowSkip::x4};

    vector<RowSkip::e> rowSkips(rs, rs + 3);

//     ColSkip::e cs[] = { ColSkip::none, ColSkip::x2, ColSkip::x3, ColSkip::x4,
//                ColSkip::x5, ColSkip::x6, ColSkip::x7 };
    ColSkip::e cs[] = { ColSkip::none, ColSkip::x2, ColSkip::x4};

    vector<ColSkip::e> colSkips(cs, cs + 3);

//    RowBin::e rb[] = { RowBin::none, RowBin::x2, RowBin::x3, RowBin::x4 };
    RowBin::e rb[] = { RowBin::none, RowBin::x2, RowBin::x4 };
    vector<RowBin::e> rowBins(rb, rb + 3);

    ColBin::e cb[] = { ColBin::none, ColBin::x2, ColBin::x4 };
    vector<ColBin::e> colBins(cb, cb + 3);    

    vector<bool> changeRoiXY(2);
    changeRoiXY[0] = false;
    changeRoiXY[1] = true;

    int roiXstd = 0;
    int roiYstd = 0;
    int roiXchg = 500;
    int roiYchg = 500;

    int dstRealFT, srcRealFT;
    int dstRealExp, srcRealExp;

    Shot srcShot, dstShot;
    srcShot.gain = 8;
    srcShot.image = FCam::Image(640,480,FCam::UYVY, FCam::Image::Discard);
    dstShot = srcShot; 

    Sensor sensor;

    unsigned int burstCount = 10;       
    unsigned int n = 6;

    snprintf(buf, 256, "sExp(ms), sFT(ms), sRS, sCS, sRB, sCB, sSX, sSY,   dExp(ms), dFT(ms), dRS, dCS, dRB, dCB, dSX, dSY");
    printf(buf); fprintf(fp, buf);
    for (unsigned int k=0; k <n ; k++) {
    snprintf(buf, 256, ",   exp_ms[%d], ft_ms[%d], avg_dT_ms[%d], std_dT_us[%d], cnt[%d]", k,k,k,k,k);
    printf(buf); fprintf(fp, buf);
    }
    snprintf(buf, 256, "\n");
    printf(buf); fprintf(fp,buf);

    for (vector<int>::iterator fTime = frameTimes.begin(); fTime != frameTimes.end(); fTime++) {
    for (vector<int>::iterator exp = exposures.begin(); exp != exposures.end(); exp++) {
    //    for (vector<bool>::iterator rXY = changeRoiXY.begin(); rXY != changeRoiXY.end(); rXY++) {
    for (int sb=0; sb < 3; sb++) {
    srcShot.roiStartX = roiXstd;
    srcShot.roiStartY = roiYstd;
    srcShot.rowSkip = rowSkips[sb]; srcShot.colSkip = colSkips[sb];
    srcShot.rowBin = rowBins[sb]; srcShot.colBin = colBins[sb];
    srcShot.frameTime = *fTime;
    srcShot.exposure = *exp;
    for (vector<int>::iterator fTime2 = frameTimes.begin(); fTime2 != frameTimes.end(); fTime2++) {
    for (vector<int>::iterator exp2 = exposures.begin(); exp2 != exposures.end(); exp2++) {
        for (int sb2 =0; sb2< 3; sb2++) {
        dstShot.roiStartX = roiXstd; //*rXY ? roiXchg : roiXstd;
        dstShot.roiStartY = roiYstd; //*rXY ? roiYchg : roiYstd;
        dstShot.rowSkip = rowSkips[sb2]; dstShot.colSkip = colSkips[sb2];
        dstShot.rowBin = rowBins[sb2]; dstShot.colBin = colBins[sb2];
        dstShot.frameTime = *fTime2;
        dstShot.exposure = *exp2;

        std::vector<Shot> testBurst(n);
        
        unsigned int i=0;
        for (; i < n/2; i++) {
        testBurst[i] = srcShot;
        }
        for (; i < n; i++) {
        testBurst[i] = dstShot;
        }
        int chgIndex = n/2;

        sensor.debugTiming(true);

        sensor.capture(dstShot); // Extra frame to allow for nice deltaTs
        for (unsigned int i=0; i< burstCount; i++) sensor.capture(testBurst);
        
        FCam::Time prevT;
        {
        Frame::Ptr f = sensor.getF2Frame();
        prevT = f->processingDoneTime;
        }
        vector<float> dT[n];
        float driverExp[n], driverFT[n];
        for (unsigned int i=0;i<n;i++) driverExp[i] = driverFT[i] = 0; 

        int testFrames = burstCount * n;
        int index = 0;
        while (testFrames-- > 0) {
        Frame::Ptr f = sensor.getF2Frame();
        
        float deltaT = (f->processingDoneTime - prevT) / 1000.0;
        prevT = f->processingDoneTime;
        
        dT[index].push_back(deltaT);
        driverExp[index] += f->exposure;
        driverFT[index] += f->frameTime;
        index = (index + 1) % n;
        }

        float avg[n];
        float std[n];
        for (unsigned int k=0;k<n;k++) {
        avg[k] = 0;
        for (unsigned int i=0; i < dT[k].size(); i++) 
            avg[k] += dT[k][i];
        avg[k] /= dT[k].size();

        std[k] = 0;
        for (unsigned int i=0; i < dT[k].size(); i++) 
            std[k] += (dT[k][i] - avg[k])*(dT[k][i] - avg[k]);
        std[k] = sqrt( std[k] / dT[k].size());
        }

        snprintf(buf,256, "%.2f, %.2f, %d, %d, %d, %d, %d, %d,    ",
           srcShot.exposure/1000.f, srcShot.frameTime/1000.f, 
           srcShot.rowSkip, srcShot.colSkip, srcShot.rowBin, srcShot.colBin, 
           srcShot.roiStartX, srcShot.roiStartY);
        printf(buf); fprintf(fp, buf);

        snprintf(buf,256, "%.2f, %.2f, %d, %d, %d, %d, %d, %d",
           dstShot.exposure/1000.f, dstShot.frameTime/1000.f, 
           dstShot.rowSkip, dstShot.colSkip, dstShot.rowBin, dstShot.colBin, 
           dstShot.roiStartX, dstShot.roiStartY);
        printf(buf); fprintf(fp, buf);
        for (unsigned int k=0; k < n; k++) {
        if ( k % 3 == 0) printf("\n\t");
        snprintf(buf,256, ",    %.1f, %.1f, %.2f, %.1f, %d", 
             driverExp[k]/dT[k].size()/1000, driverFT[k]/dT[k].size()/1000,
             avg[k], std[k]*1000, dT[k].size());
        printf(buf); fprintf(fp, buf);
        }
        snprintf(buf,256,"\n");
        printf(buf); fprintf(fp,buf);

        fflush(fp);
        if (sensor.framesPending()) {
        printf("!! Still got frames, that's not good\n");
        }

    }
    }
    }
    }
    }
    //    }
    }
}

void syncTest() {
    using namespace FCam::F2;
    using namespace std;

    printf("syncTest: Testing basic frame-level control\n"
       "-------------------------------------------\n");

    // Initialize a sensor
    Sensor sensor;
    unsigned int n = 10;

    // Create a n-image burst with one image with different parameters

    Burst testShots(1);

    testShots[0].exposure = 1000;
    testShots[0].gain = 10;
    testShots[0].frameTime = 40000;
    testShots[0].image = FCam::Image(640, 480, FCam::UYVY);

    for (unsigned int i=1; i < n;i++) {
    testShots.push_back(testShots[0]);
    testShots[i].image = FCam::Image(640,480, FCam::UYVY);
    if (i >= n/2) testShots[i].exposure = 20000; //25000;
    }
    testShots[n-1].exposure = 40000;

    sensor.stream(testShots);

    vector<vector<float> > lums(n);
    vector<vector<float> > deltaT(n);

    int testFrames = n*10;
    FCam::Time prevTime = FCam::Time::now();
    bool startup = true;
    int startupIgnoreCount = 0; //n-1;

    printf("* Capturing %d frames of a %d-shot burst\n", testFrames, n);
    while (testFrames-- > 0) {
    unsigned int index;
    FCam::Frame::Ptr f = sensor.getFrame();
    
    for (index=0; index<n ;index++ ) {
        if (testShots[index].id == f->shot().id) break;
    }
    if (index == n) {
        printf("Unknown frame returned! Something wrong in the shot cloning, perhaps?\n");
        exit(0);
    }

    if (startupIgnoreCount-- == 0)
        startup=false;

    if (!startup) {
        float dt = (f->processingDoneTime-prevTime) / 1000.;
        printf("Frame %d: Time from previous frame: %.2f ms, supposed to be %.2f\n", index, dt,
           f->frameTime/1000.);
        deltaT[index].push_back(dt);
    } 

    prevTime = f->processingDoneTime;
        
    if (!f->image.valid()) {
        printf(" Frame %d Came back with no image data!\n", index);
        continue;
    } 

    // Calculate some statistics 
    unsigned int totalY=0;
    unsigned char *yPtr = f->image.data+1; // Offset to get to a Y
    unsigned int count=0;
    while (yPtr < f->image.data + 2*f->image.size.width*f->image.size.height) {
        totalY+= *yPtr;
        yPtr += 100;
        count++;
    }   
    lums[index].push_back( ((float)totalY)/count);
    }
    sensor.stopStreaming();

    printf("Writing stats to syncTest.csv\n");
    ofstream stats("syncTest.csv");   
    bool done = false;
    unsigned int row = 0;
    while (!done) { 
    int haveData=0;
    for (unsigned int i=0;i < n; i++) {
        if (row < lums[i].size()) {
        stats << lums[i][row] << ", ";
        haveData++;
        } else {
        stats << "-1 ,";
        }
        if (row < deltaT[i].size()) {
        stats << deltaT[i][row];
        haveData++;
        } else {
        stats << "-1";
        }
        if (i < n-1)
        stats << " ,";
    }
    stats << endl;
    if (haveData == 0) done = true;
    row++;
    }
    stats.close();

    printf("\n\n** Results (Y=sampled luminance per pixel, T=inter-frame time)\n\n");
    // Calculate averages, stddevs
    vector<float> avgsL(n), stddevsL(n), lowboundL(n), highboundL(n);
    vector<float> avgsT(n), stddevsT(n), lowboundT(n), highboundT(n);
    for (unsigned int i=0;i<n;i++) {
    avgsL[i] = 0;
    stddevsL[i] = 0;
    for (unsigned int j=0;j < lums[i].size(); j++) {
        avgsL[i] += lums[i][j];
    }
    avgsL[i] /= lums[i].size();
    for (unsigned int j=0;j < lums[i].size(); j++) {
        stddevsL[i] += (lums[i][j] - avgsL[i])*(lums[i][j] - avgsL[i]);
    }
    stddevsL[i] /= lums[i].size();
    stddevsL[i] = sqrt(stddevsL[i]);    
    sort(lums[i].begin(), lums[i].end());
    if (lums[i].size()>10) {
        lowboundL[i] = lums[i][lums[i].size()/10];
        highboundL[i] = lums[i][lums[i].size()*9/10];
    } else {
        lowboundL[i]=-1;
        highboundL[i]=-1;
    }
    printf("Shot %d cnt %d, Lum: Avg: %.1f, Std: %.1f, 10%%: %f, 90%%: %f\n", i, lums[i].size(), avgsL[i], stddevsL[i], lowboundL[i], highboundL[i]);
    }    
    printf("\n");
    for (unsigned int i=0;i<n;i++) {
    avgsT[i] = 0;
    stddevsT[i] = 0;
    for (unsigned int j=0;j < deltaT[i].size(); j++) {
        avgsT[i] += deltaT[i][j];
    }
    avgsT[i] /= deltaT[i].size();
    for (unsigned int j=0;j < deltaT[i].size(); j++) {
        stddevsT[i] += (deltaT[i][j] - avgsT[i])*(deltaT[i][j] - avgsT[i]);
    }
    stddevsT[i] /= deltaT[i].size();
    stddevsT[i] = sqrt(stddevsT[i]);
    sort(deltaT[i].begin(), deltaT[i].end());
    if (deltaT[i].size()>10){
        lowboundT[i] = deltaT[i][deltaT[i].size()/10];
        highboundT[i] = deltaT[i][deltaT[i].size()*9/10];
    } else {
        lowboundT[i] = -1;
        highboundT[i] = -1;
    }
    printf("Shot %d, Interframe delay: Avg: %.3f ms, Std: %.2f us, 10%%: %.2f, 90%%: %.2f Exp: %.1f ms\n",
           i, avgsT[i], stddevsT[i]*1000, lowboundT[i], highboundT[i], testShots[i].exposure/1000. );
    }

    printf("syncTest: Done\n"
       "-------------------------------------------\n");

}

void basicTest() {
    using namespace FCam;
    using namespace std;

    printf("basicTest: Testing basic capture in all formats\n"
       "-------------------------------------------\n");

    unsigned int n = 15;
    F2::Sensor sensor;
    F2::Shot testShot;
    AsyncFileWriter writer;

    testShot.exposure = 40000;
    testShot.frameTime = 0;
    testShot.gain = 8;
    
    // Get 640x480 UYVY images
    
    printf("=== 640x480 UYVY ===\n");
    testShot.image = Image(640,480,UYVY, Image::Discard);
    testShot.roiRegionSmaller(sensor.maxImageSize());
    for (int i=0;i < n;i++) sensor.capture(testShot);
    for (int i=0;i < n;i++) { sensor.getFrame(); printf("\tGot frame %d\n", i); }
    
    
    // Get 5 MP UYVY images
    printf("=== 5MP UYVY ===\n");
    testShot.image = Image(sensor.maxImageSize(), UYVY, Image::Discard);
    testShot.roiRegionSmaller(sensor.maxImageSize());
    {
    //Frame::Ptr f[n];
    for (int i=0;i < n;i++) sensor.capture(testShot);
    for (int i=0;i < n;i++) { sensor.getFrame(); printf("\tGot frame %d\n", i); }        
    //for (int i=0;i < n;i++) { f[i] = sensor.getFrame(); printf("\tGot frame %d\n", i); }
    //for (int i=0;i< n; i++) { char name[256]; snprintf(name,256, "basic_%02d.yuyv", i); saveUYVY(f[i], name); }
    }
    
    
    // Get 5 MP RAW images
    printf("=== 5MP RAW ===\n");
    testShot.image = Image(sensor.maxImageSize(), RAW, Image::Discard);
    testShot.roiRegionSmaller(sensor.maxImageSize());
    {
    //Frame::Ptr f[n];
    for (int i=0;i < n;i++) sensor.capture(testShot);
    for (int i=0;i < n;i++) { sensor.getFrame(); printf("\tGot frame %d\n", i); }        
    //for (int i=0;i < n;i++) { f[i]=sensor.getFrame(); printf("\tGot frame %d\n", i); }        
    //for (int i=0;i< n; i++) { char name[256]; snprintf(name,256, "basic_%02d.dng", i); saveDNG(f[i], name); }
    }
   
    // Get 640x480 RAW images
    printf("=== 640x480 RAW ===\n");
    //sensor.debugTiming(true);
    testShot.image = Image(640,480,RAW, Image::AutoAllocate);
    testShot.roiRegionSmaller(sensor.maxImageSize());
    for (int i=0;i < n;i++) sensor.capture(testShot);
    for (int i=0;i < n;i++) { sensor.getFrame(); printf("\tGot frame %d\n", i); }        

    // Get 640x480 UYVY images again
    
    printf("=== 640x480 UYVY again ===\n");
    testShot.image = Image(640,480,UYVY, Image::Discard);
    testShot.roiRegionSmaller(sensor.maxImageSize());
    for (int i=0;i < n;i++) sensor.capture(testShot);
    for (int i=0;i < n;i++) { sensor.getFrame(); printf("\tGot frame %d\n", i); }
    

    /*
    for (int i=0;i < n;i++) { 
    Frame::Ptr f=sensor.getFrame(); 
    
    printf("\tGot frame %d\n", i); 
    char name[256]; snprintf(name,256, "basic_%02d.dng", i); 
    writer.saveDNG(f, name);
    }
    */    
}

void usage() {
    printf("test_F2 Usage:\n\ntest_F2 <test1> <test2> ...\n");
    printf("Available tests:\n");
    printf("\tb\tBasic\tJust try capturing some frames in UYVY/RAW modes and 640x48/5 MP\n");
    printf("\ts\tSync\tTest timing of shot parameter changes\n");
    printf("\tr\tRoi Timing\tCollect a lot of statistics. Takes a while, writes roiTiming.csv as it goes\n");
}

int main(int argc, char **argv) {
    if (argc > 1) {
    printf("Starting F2 FCam API tests\n"
           "===============================\n");
    for (int i=1; i < argc; i++) {
        switch(argv[i][0]) {
        case 'b':
        case 'B':
        basicTest();
        break;
        case 's':
        case 'S':
        syncTest();
        break;
        case 'r':
        case 'R':
        roiTimingTest();
        break;
        default:
        printf("Unknown test %s\n", argv[0]);
        usage();
        break;
        };
    }
    printf("===============================\n"
           "Done with tests\n"
           );

    } else {
    usage();
    }
}