Example #1
0
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");

}